/* * for each input dataset name * open (check dims, etc.) * dilate (zeropad, make binary, dilate, unpad, apply) * fill list of bytemask datasets * * also, count total volumes */ int process_input_dsets(param_t * params) { THD_3dim_dataset * dset, * dfirst=NULL; int iset, nxyz; ENTRY("process_input_dsets"); if( !params ) ERROR_exit("NULL inputs to PID"); if( params->ndsets <= 0 ) { ERROR_message("process_input_dsets: no input datasets"); RETURN(1); } /* allocate space for dsets array */ params->dsets = (THD_3dim_dataset **)malloc(params->ndsets* sizeof(THD_3dim_dataset*)); if( !params->dsets ) ERROR_exit("failed to allocate dset pointers"); if( params->verb ) INFO_message("processing %d input datasets...", params->ndsets); /* warn user of dilations */ if(params->verb && params->ndsets) { int pad = needed_padding(¶ms->IND); INFO_message("padding all datasets by %d (for dilations)", pad); } /* process the datasets */ nxyz = 0; for( iset=0; iset < params->ndsets; iset++ ) { /* open and verify dataset */ dset = THD_open_dataset(params->inputs[iset]); if( !dset ) ERROR_exit("failed to open mask dataset '%s'", params->inputs[iset]); DSET_load(dset); CHECK_LOAD_ERROR(dset); if( params->verb>1 ) INFO_message("loaded dset %s, with %d volumes", DSET_PREFIX(dset), DSET_NVALS(dset)); if( nxyz == 0 ) { /* make an empty copy of the first dataset */ nxyz = DSET_NVOX(dset); dfirst = EDIT_empty_copy(dset); } /* check for consistency in voxels and grid */ if( DSET_NVOX(dset) != nxyz ) ERROR_exit("nvoxel mis-match"); if( ! EQUIV_GRIDS(dset, dfirst) ) WARNING_message("grid from dset %s does not match that of dset %s", DSET_PREFIX(dset), DSET_PREFIX(dfirst)); /* apply dilations to all volumes, returning bytemask datasets */ params->dsets[iset] = apply_dilations(dset, ¶ms->IND,1,params->verb); if( ! params->dsets[iset] ) RETURN(1); } DSET_delete(dfirst); /* and nuke */ RETURN(0); }
/* A debugging function to show the state of the various file naming fields */ void THD_show_dataset_names( THD_3dim_dataset *dset, char *head, FILE *out) { if (!dset) { fprintf(stderr,"NULL dset"); return; } if (!out) out = stderr; if (head && !strcmp(head,"FOR_3DINFO")) { fprintf(out, " filecode: %s" " header_name: %s" " brick_name: %s" " prefix: %s" " storage_mode: %d", dset->dblk->diskptr->filecode, dset->dblk->diskptr->header_name, dset->dblk->diskptr->brick_name, DSET_PREFIX(dset), dset->dblk->diskptr->storage_mode); } else { fprintf(out, "*** FileLove: %s\n" " filecode: %s\n" " header_name: %s\n" " brick_name: %s\n" " prefix: %s\n" " storage_mode: %d\n", head ? head:"", dset->dblk->diskptr->filecode, dset->dblk->diskptr->header_name, dset->dblk->diskptr->brick_name, DSET_PREFIX(dset), dset->dblk->diskptr->storage_mode); } return; }
THD_3dim_dataset *Seg_load_dset_eng( char *set_name, char *view ) { static char FuncName[]={"Seg_load_dset_eng"}; THD_3dim_dataset *dset=NULL, *sdset=NULL; int i=0; byte make_cp=0; int verb=0; char sprefix[THD_MAX_PREFIX+10], *stmp=NULL; SUMA_ENTRY; dset = THD_open_dataset( set_name ); if( !ISVALID_DSET(dset) ){ fprintf(stderr,"**ERROR: can't open dataset %s\n",set_name) ; SUMA_RETURN(NULL); } DSET_mallocize(dset) ; DSET_load(dset); for (i=0; i<DSET_NVALS(dset); ++i) { if (DSET_BRICK_TYPE(dset,i) != MRI_short) { if (verb) INFO_message("Sub-brick %d in %s not of type short.\n" "Creating new short copy of dset ", i, DSET_PREFIX(dset)); make_cp=1; break; } } if (make_cp) { if (!SUMA_ShortizeDset(&dset, -1.0)) { SUMA_S_Err("**ERROR: Failed to shortize"); SUMA_RETURN(NULL); } } if (DSET_IS_MASTERED(dset)) { if (verb) INFO_message("Dset is mastered, making copy..."); stmp = SUMA_ModifyName(set_name, "append", ".cp", NULL); sdset = dset; dset = EDIT_full_copy(sdset, stmp); free(stmp); DSET_delete(sdset); sdset = NULL; } if (view) { if (view) { if (!strstr(view,"orig")) EDIT_dset_items(dset,ADN_view_type, VIEW_ORIGINAL_TYPE, ADN_none); else if (!strstr(view,"acpc")) EDIT_dset_items(dset,ADN_view_type, VIEW_ACPCALIGNED_TYPE, ADN_none); else if (!strstr(view,"tlrc")) EDIT_dset_items(dset ,ADN_view_type, VIEW_TALAIRACH_TYPE, ADN_none); else SUMA_S_Errv("View of %s is rubbish", view); } } SUMA_RETURN(dset); }
/* convert by hand, since no scaling will be done * (byte seems inappropriate and float does not need it) */ int write_result(param_t * params, THD_3dim_dataset * oset, int argc, char * argv[]) { short * sptr; int nvox = DSET_NVOX(oset), ind; ENTRY("write_results"); EDIT_dset_items(oset, ADN_prefix, params->prefix, ADN_none); if( params->verb ) INFO_message("writing result %s...\n", DSET_PREFIX(oset)); switch( params->datum ) { default: ERROR_exit("invalid datum for result: %d", params->datum); case MRI_short: break; /* nothing to do */ case MRI_float: { float * data = (float *)malloc(nvox*sizeof(float)); sptr = DBLK_ARRAY(oset->dblk, 0); if( ! data ) ERROR_exit("failed to alloc %d output floats\n", nvox); for( ind = 0; ind < nvox; ind++ ) data[ind] = (float)sptr[ind]; EDIT_substitute_brick(oset, 0, params->datum, data); } break; case MRI_byte: { byte * data = (byte *)malloc(nvox*sizeof(byte)); int errs = 0; sptr = DBLK_ARRAY(oset->dblk, 0); if( ! data ) ERROR_exit("failed to alloc %d output bytes\n", nvox); for( ind = 0; ind < nvox; ind++ ) { if( sptr[ind] > 255 ) { /* watch for overflow */ data[ind] = (byte)255; errs++; } else data[ind] = (byte)sptr[ind]; } EDIT_substitute_brick(oset, 0, params->datum, data); if(errs) WARNING_message("convert to byte: %d truncated voxels",errs); } break; } tross_Make_History( "3dmask_tool", argc, argv, oset ); DSET_write(oset); WROTE_DSET(oset); RETURN(0); }
/* Return the prefix of a dataset without file extensions Returned string must be freed */ char *DSET_prefix_noext(THD_3dim_dataset *dset) { char *ppp, *eee, *ccc=NULL; int ii; if (!dset) return(NULL); ppp = DSET_PREFIX(dset); if (!ppp) ppp = "NO_PREFIX"; ccc = (char *)malloc(sizeof(char)*(1+strlen(ppp))); ccc[0]='\0'; eee = find_filename_extension( ppp ); if (!eee) { strcpy(ccc, ppp); } else { ii = 0; while (ppp < eee) { ccc[ii] = *ppp; ppp++; ++ii; } ccc[ii]='\0'; } return(ccc); }
int main( int argc , char * argv[] ) { int iarg ; THD_3dim_dataset *inset , *outset ; int add_I=0 , add_S=0 , add_A=0 , add_P=0 , add_L=0 , add_R=0 ; int RLsiz=0, APsiz=0, ISsiz=0 ; /* 23 Mar 2004 */ char * prefix="zeropad" ; int add_z=0 ; /* 07 Feb 2001 */ int mm_flag=0 ; /* 13 Feb 2001 */ int flag ; THD_3dim_dataset *mset=NULL ; /* 14 May 2002 */ /*-- help? --*/ mainENTRY("3dZeropad main"); machdep(); AFNI_logger("3dZeropad",argc,argv); PRINT_VERSION("3dZeropad") ; /*-- read command line options --*/ if( argc == 1){ usage_3dZeropad(1); exit(0); } /* Bob's help shortcut */ iarg = 1 ; while( iarg < argc && argv[iarg][0] == '-' ){ if( strcmp(argv[iarg],"-help") == 0 || strcmp(argv[iarg],"-h") == 0){ usage_3dZeropad(strlen(argv[iarg])>3 ? 2:1); exit(0); } /*- -I, -S, etc. -*/ if( strlen(argv[iarg]) == 2 ){ switch( argv[iarg][1] ){ case 'I': add_I = (int) strtod(argv[++iarg],NULL) ; break ; case 'S': add_S = (int) strtod(argv[++iarg],NULL) ; break ; case 'A': add_A = (int) strtod(argv[++iarg],NULL) ; break ; case 'P': add_P = (int) strtod(argv[++iarg],NULL) ; break ; case 'L': add_L = (int) strtod(argv[++iarg],NULL) ; break ; case 'R': add_R = (int) strtod(argv[++iarg],NULL) ; break ; /* 07 Feb 2001: slice-direction is special */ case 'z': case 'Z': add_z = (int) strtod(argv[++iarg],NULL) ; break ; default: fprintf(stderr,"** 3dZeropad: Illegal option: %s\n",argv[iarg]) ; exit(1) ; } if( mset != NULL ){ fprintf(stderr,"** 3dZeropad: Can't use %s with -master!\n",argv[iarg-1]) ; exit(1) ; } iarg++ ; continue ; /* skip to next argument */ } /*- -RL, -AP, -IS [23 Mar 2004] -*/ if( strcmp(argv[iarg],"-RL") == 0 || strcmp(argv[iarg],"-LR") == 0 ){ if( add_R || add_L || mset != NULL ){ fprintf(stderr,"** 3dZeropad: Can't use -RL with -R, -L, or -master!\n"); exit(1) ; } RLsiz = (int) strtod(argv[++iarg],NULL) ; if( RLsiz < 1 ){ fprintf(stderr,"** 3dZeropad: value after -RL is illegal!\n") ; exit(1) ; } iarg++ ; continue ; } if( strcmp(argv[iarg],"-AP") == 0 || strcmp(argv[iarg],"-PA") == 0 ){ if( add_A || add_P || mset != NULL ){ fprintf(stderr,"** 3dZeropad: Can't use -AP with -A, -P, or -master!\n"); exit(1) ; } APsiz = (int) strtod(argv[++iarg],NULL) ; if( APsiz < 1 ){ fprintf(stderr,"** 3dZeropad: value after -AP is illegal!\n") ; exit(1) ; } iarg++ ; continue ; } if( strcmp(argv[iarg],"-IS") == 0 || strcmp(argv[iarg],"-SI") == 0 ){ if( add_S || add_I || mset != NULL ){ fprintf(stderr,"** 3dZeropad: Can't use -IS with -I, -S, or -master!\n"); exit(1) ; } ISsiz = (int) strtod(argv[++iarg],NULL) ; if( ISsiz < 1 ){ fprintf(stderr,"** 3dZeropad: value after -IS is illegal!\n") ; exit(1) ; } iarg++ ; continue ; } /*- -mm -*/ if( strcmp(argv[iarg],"-mm") == 0 ){ if( mset != NULL ){ fprintf(stderr,"** 3dZeropad: Can't use %s with -master!\n",argv[iarg]) ; exit(1) ; } mm_flag = 1 ; iarg++ ; continue ; } /*- -prefix -*/ if( strcmp(argv[iarg],"-prefix") == 0 ){ prefix = argv[++iarg] ; if( !THD_filename_ok(prefix) ){ fprintf(stderr,"** 3dZeropad: Illegal string after -prefix!\n"); exit(1) ; } iarg++ ; continue ; } /*-- -master [14 May 2002] --*/ if( strcmp(argv[iarg],"-master") == 0 ){ if( add_I || add_S || add_A || mm_flag || add_P || add_R || add_L || add_z || RLsiz || APsiz || ISsiz ){ fprintf(stderr,"** 3dZeropad: Can't use -master with -I,-S,-A,-P,-R,-L, or -mm!\n"); exit(1) ; } if( mset != NULL ){ fprintf(stderr,"** 3dZeropad: Can't use -master twice!\n"); exit(1); } mset = THD_open_dataset( argv[++iarg] ) ; if( !ISVALID_DSET(mset) ){ fprintf(stderr,"** 3dZeropad: Can't open -master %s\n",argv[iarg]); exit(1); } THD_make_cardinal(mset); /* deoblique 21 Oct, 2011 [rickr] */ iarg++ ; continue ; } /*- what the hell? -*/ fprintf(stderr,"** 3dZeropad: Illegal option: %s\n",argv[iarg]) ; suggest_best_prog_option(argv[0], argv[iarg]); exit(1) ; } if (iarg < 2) { ERROR_message("Too few options, try %s -help for details\n",argv[0]); exit(1); } /*- check to see if the user asked for something, anything -*/ if( mset == NULL ){ if( add_I==0 && add_S==0 && add_P==0 && add_A==0 && add_L==0 && add_R==0 && add_z==0 && RLsiz==0 && APsiz==0 && ISsiz==0 ){ fprintf(stderr,"++ 3dZeropad: All inputs are zero? Making a copy!\n") ; } } /* check for conflicts [23 Mar 2004] */ if( RLsiz > 0 && (add_R || add_L || add_z) ){ fprintf(stderr,"** 3dZeropad: Can't use -R or -L or -z with -RL!\n"); exit(1); } if( APsiz > 0 && (add_A || add_P || add_z) ){ fprintf(stderr,"** 3dZeropad: Can't use -A or -P or -z with -AP!\n"); exit(1); } if( ISsiz > 0 && (add_I || add_S || add_z) ){ fprintf(stderr,"** 3dZeropad: Can't use -I or -S or -z with -IS!\n"); exit(1); } /*-- read the input dataset --*/ if( iarg >= argc ){ fprintf(stderr,"** 3dZeropad: No input dataset on command line!\n"); exit(1); } #if 0 if( strncmp(argv[iarg],"3dcalc(",7) == 0 ){ fprintf(stderr,"** 3dZeropad: Can't use '3dcalc()' input datasets here!\n"); exit(1); } #endif inset = THD_open_dataset( argv[iarg] ) ; if( inset == NULL ){ fprintf(stderr,"** 3dZeropad: Can't open dataset %s\n",argv[iarg]); exit(1); } THD_make_cardinal(inset); /* deoblique 21 Oct, 2011 [rickr] */ #if 0 if( DSET_IS_MASTERED(inset) ){ fprintf(stderr,"** 3dZeropad: Can't use partial datasets!\n"); exit(1); } #endif /*-- 14 May 2002: use master dataset now? --*/ if( mset != NULL ){ THD_dataxes *max=mset->daxes, *iax=inset->daxes ; int nerr=0 ; float mxbot,mybot,mzbot , mxtop,mytop,mztop , mdx,mdy,mdz ; float ixbot,iybot,izbot , ixtop,iytop,iztop , idx,idy,idz ; int mnx,mny,mnz , inx,iny,inz ; int add_xb,add_xt , add_yb,add_yt , add_zb,add_zt ; /* check if datasets are oriented the same */ if( max->xxorient != iax->xxorient || max->yyorient != iax->yyorient || max->zzorient != iax->zzorient ){ fprintf(stderr, "** 3dZeropad: Master (%s) and Input (%s) dataset not oriented the same!\n", DSET_PREFIX(mset), DSET_PREFIX(inset)); nerr++ ; } /* check if datasets have same voxel dimensions */ mdx = max->xxdel ; mdy = max->yydel ; mdz = max->zzdel ; idx = iax->xxdel ; idy = iax->yydel ; idz = iax->zzdel ; mnx = max->nxx ; mny = max->nyy ; mnz = max->nzz ; inx = iax->nxx ; iny = iax->nyy ; inz = iax->nzz ; if( fabs(mdx-idx) > 0.01*fabs(mdx) || fabs(mdy-idy) > 0.01*fabs(mdy) || fabs(mdz-idz) > 0.01*fabs(mdz) ){ fprintf(stderr,"** 3dZeropad: Master and Input datasets don't have same voxel size!\n"); nerr++ ; } if( nerr ) exit(1) ; /* calculate coords at top and bottom of each dataset */ mxbot = max->xxorg ; mxtop = mxbot + mnx*mdx ; mybot = max->yyorg ; mytop = mybot + mny*mdy ; mzbot = max->zzorg ; mztop = mzbot + mnz*mdz ; ixbot = iax->xxorg ; ixtop = ixbot + inx*idx ; iybot = iax->yyorg ; iytop = iybot + iny*idy ; izbot = iax->zzorg ; iztop = izbot + inz*idz ; /* calculate amount to add/trim at each face */ add_xb = (int) rint((ixbot-mxbot)/idx) ; add_xt = (int) rint((mxtop-ixtop)/idx) ; add_yb = (int) rint((iybot-mybot)/idy) ; add_yt = (int) rint((mytop-iytop)/idy) ; add_zb = (int) rint((izbot-mzbot)/idz) ; add_zt = (int) rint((mztop-iztop)/idz) ; /* map trims from x,y,z to RL,AP,IS coords */ switch( iax->xxorient ){ case ORI_R2L_TYPE: add_R = add_xb ; add_L = add_xt ; break ; case ORI_L2R_TYPE: add_L = add_xb ; add_R = add_xt ; break ; case ORI_I2S_TYPE: add_I = add_xb ; add_S = add_xt ; break ; case ORI_S2I_TYPE: add_S = add_xb ; add_I = add_xt ; break ; case ORI_A2P_TYPE: add_A = add_xb ; add_P = add_xt ; break ; case ORI_P2A_TYPE: add_P = add_xb ; add_A = add_xt ; break ; } switch( iax->yyorient ){ case ORI_R2L_TYPE: add_R = add_yb ; add_L = add_yt ; break ; case ORI_L2R_TYPE: add_L = add_yb ; add_R = add_yt ; break ; case ORI_I2S_TYPE: add_I = add_yb ; add_S = add_yt ; break ; case ORI_S2I_TYPE: add_S = add_yb ; add_I = add_yt ; break ; case ORI_A2P_TYPE: add_A = add_yb ; add_P = add_yt ; break ; case ORI_P2A_TYPE: add_P = add_yb ; add_A = add_yt ; break ; } switch( iax->zzorient ){ case ORI_R2L_TYPE: add_R = add_zb ; add_L = add_zt ; break ; case ORI_L2R_TYPE: add_L = add_zb ; add_R = add_zt ; break ; case ORI_I2S_TYPE: add_I = add_zb ; add_S = add_zt ; break ; case ORI_S2I_TYPE: add_S = add_zb ; add_I = add_zt ; break ; case ORI_A2P_TYPE: add_A = add_zb ; add_P = add_zt ; break ; case ORI_P2A_TYPE: add_P = add_zb ; add_A = add_zt ; break ; } fprintf(stderr,"++ 3dZeropad -master => -I %d -S %d -A %d -P %d -R %d -L %d\n", add_I,add_S,add_A,add_P,add_R,add_L ) ; DSET_delete(mset) ; } /*-- 07 Feb 2001: if -z was used, fix that now --*/ if( add_z != 0 ){ switch( inset->daxes->zzorient ){ case ORI_R2L_TYPE: case ORI_L2R_TYPE: if( add_R != 0 && add_R != add_z ) fprintf(stderr,"++ 3dZeropad: -z overrides -R\n"); if( add_L != 0 && add_L != add_z ) fprintf(stderr,"++ 3dZeropad: -z overrides -L\n"); add_R = add_L = add_z ; break ; case ORI_P2A_TYPE: case ORI_A2P_TYPE: if( add_P != 0 && add_P != add_z ) fprintf(stderr,"++ 3dZeropad: -z overrides -P\n"); if( add_A != 0 && add_A != add_z ) fprintf(stderr,"++ 3dZeropad: -z overrides -A\n"); add_P = add_A = add_z ; break ; case ORI_I2S_TYPE: case ORI_S2I_TYPE: if( add_I != 0 && add_I != add_z ) fprintf(stderr,"++ 3dZeropad: -z overrides -I\n"); if( add_I != 0 && add_S != add_z ) fprintf(stderr,"++ 3dZeropad: -z overrides -S\n"); add_I = add_S = add_z ; break ; } } /*-- 23 Mar 2004: expand/contract if ordered --*/ if( RLsiz > 0 ){ int nold=0 ; if( inset->daxes->xxorient == ORI_R2L_TYPE || inset->daxes->xxorient == ORI_L2R_TYPE ) nold = inset->daxes->nxx ; else if( inset->daxes->yyorient == ORI_R2L_TYPE || inset->daxes->yyorient == ORI_L2R_TYPE ) nold = inset->daxes->nyy ; else if( inset->daxes->zzorient == ORI_R2L_TYPE || inset->daxes->zzorient == ORI_L2R_TYPE ) nold = inset->daxes->nzz ; if( nold > 0 ){ add_R = (RLsiz-nold) / 2 ; add_L = RLsiz-(nold+add_R) ; } } if( APsiz > 0 ){ int nold=0 ; if( inset->daxes->xxorient == ORI_A2P_TYPE || inset->daxes->xxorient == ORI_P2A_TYPE ) nold = inset->daxes->nxx ; else if( inset->daxes->yyorient == ORI_A2P_TYPE || inset->daxes->yyorient == ORI_P2A_TYPE ) nold = inset->daxes->nyy ; else if( inset->daxes->zzorient == ORI_A2P_TYPE || inset->daxes->zzorient == ORI_P2A_TYPE ) nold = inset->daxes->nzz ; if( nold > 0 ){ add_A = (APsiz-nold) / 2 ; add_P = APsiz-(nold+add_A) ; } } if( ISsiz > 0 ){ int nold=0 ; if( inset->daxes->xxorient == ORI_I2S_TYPE || inset->daxes->xxorient == ORI_S2I_TYPE ) nold = inset->daxes->nxx ; else if( inset->daxes->yyorient == ORI_I2S_TYPE || inset->daxes->yyorient == ORI_S2I_TYPE ) nold = inset->daxes->nyy ; else if( inset->daxes->zzorient == ORI_I2S_TYPE || inset->daxes->zzorient == ORI_S2I_TYPE ) nold = inset->daxes->nzz ; if( nold > 0 ){ add_I = (ISsiz-nold) / 2 ; add_S = ISsiz-(nold+add_I) ; } } /*-- 04 Oct 2000: all the real work is now in thd_zeropad.c --*/ flag = ZPAD_PURGE ; if( mm_flag ) flag |= ZPAD_MM ; outset = THD_zeropad( inset , add_I, add_S, add_A, add_P, add_L, add_R, prefix , flag ) ; if( THD_deathcon() && THD_is_file(DSET_HEADNAME(outset)) ){ fprintf(stderr, "** 3dZeropad: output file %s already exists - FATAL ERROR!\n", DSET_HEADNAME(outset) ) ; exit(1) ; } if( outset == NULL ){ fprintf(stderr,"** 3dZeropad: Some error occurred in processing!\n") ; exit(1) ; } tross_Copy_History( inset , outset ) ; /* 31 Jan 2001 - RWCox */ tross_Make_History( "3dZeropad" , argc,argv , outset ) ; if (DSET_write(outset) != False) { fprintf(stderr,"++ output dataset: %s\n",DSET_BRIKNAME(outset)) ; exit(0) ; } else { fprintf(stderr, "** 3dZeropad: Failed to write output!\n" ) ; exit(1) ; } }
int main( int argc , char * argv[] ) { THD_3dim_dataset *mask_dset=NULL, *iset=NULL, *sset=NULL, *xset=NULL, *vset=NULL; char *prefix="toy"; int iarg=1 , mcount, udatum = MRI_float; byte *maskvox=NULL; mainENTRY("3dToyProg main"); machdep(); AFNI_logger("3dToyProg",argc,argv); #ifdef USING_MCW_MALLOC enable_mcw_malloc() ; #endif /*-- options --*/ set_obliquity_report(0); /* silence obliquity */ while( iarg < argc && argv[iarg][0] == '-' ){ CHECK_HELP(argv[iarg], help_3dToyProg); if( strncmp(argv[iarg],"-mask",5) == 0 ){ if (iarg >= argc) ERROR_exit("Need dset after -mask"); mask_dset = THD_open_dataset( argv[++iarg] ) ; if( mask_dset == NULL ) ERROR_exit("Cannot open mask dataset!\n") ; if( DSET_BRICK_TYPE(mask_dset,0) == MRI_complex ) ERROR_exit("Cannot deal with complex-valued mask dataset!\n"); iarg++ ; continue ; } if( strcmp(argv[iarg],"-input") == 0) { if (iarg >= argc) ERROR_exit("Need dset after -mask"); if (!(iset = THD_open_dataset( argv[++iarg]))) { ERROR_exit("Cannot open input dataset %s!\n", argv[iarg]) ; } DSET_mallocize(iset); DSET_load(iset); /* load data part of dataset */ iarg++ ; continue ; } if( strncmp(argv[iarg],"-prefix",6) == 0) { if (iarg >= argc) ERROR_exit("Need name after -prefix"); prefix = argv[++iarg]; iarg++ ; continue ; continue ; } if( strcmp(argv[iarg],"-datum") == 0) { if (iarg >= argc) ERROR_exit("Need datum type after -datum"); ++iarg; if (!strcmp(argv[iarg],"float")) udatum = MRI_float; else if (!strcmp(argv[iarg],"short")) udatum = MRI_short; else { ERROR_exit( "For the purpose of this demo, only float and short are allowed"); } iarg++ ; continue ; continue ; } ERROR_message("ILLEGAL option: %s\n",argv[iarg]) ; suggest_best_prog_option(argv[0], argv[iarg]); exit(1); } if( argc < 2 ){ help_3dToyProg(TXT, 0); PRINT_COMPILE_DATE ; exit(0) ; } if( !iset ) ERROR_exit("No dataset on command line!?") ; if (mask_dset) { if (THD_dataset_mismatch(mask_dset, iset)) ERROR_exit("grid mismatch between input dset and mask dset"); maskvox = THD_makemask( mask_dset , 0 , 1.0, -1.0 ) ; mcount = THD_countmask( DSET_NVOX(mask_dset) , maskvox ) ; if( mcount <= 0 ) ERROR_exit("No voxels in the mask!\n") ; INFO_message("%d voxels in the mask dset %s\n", mcount, DSET_PREFIX(mask_dset)) ; DSET_delete(mask_dset) ; mask_dset=NULL; /* Done with the mask dset */ } /* An illustration of how volume navigation works */ Dataset_Navigation(iset); /* Let us create a dataset from scratch */ sset = New_Dataset_From_Scratch(prefix); /* Now for the output, add history, check for overwrite and write away */ tross_Copy_History( iset , sset );/* Copy the old history (not mandatory). */ tross_Make_History("3dToyProg", argc, argv ,sset) ; /* add the new */ if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(sset)) ) { ERROR_message( "Output %s already exists, use -overwrite to do you know what", DSET_HEADNAME(sset)); } else DSET_write(sset); /* Now we'll do some voxelwise computations */ xset = Voxelwise_Operations(sset, maskvox, prefix); tross_Copy_History( iset , xset ) ; /* Copy the old */ tross_Make_History("3dToyProg", argc, argv ,xset) ; /* add the new */ if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(xset)) ) { ERROR_message( "Output %s already exists, use -overwrite to do you know what", DSET_HEADNAME(xset)); } else DSET_write(xset); /* Or some volumewise operations */ vset = Volumewise_Operations(sset, prefix, udatum); tross_Copy_History( iset , vset ) ; /* Copy the old */ tross_Make_History("3dToyProg", argc, argv ,vset) ; /* add the new */ if( !THD_ok_overwrite() && THD_is_ondisk(DSET_HEADNAME(vset)) ) { ERROR_message( "Output %s already exists, use -overwrite to do you know what", DSET_HEADNAME(vset)); } else DSET_write(vset); /* cleanup */ DSET_delete(xset); xset = NULL; DSET_delete(vset); vset = NULL; DSET_delete(sset); sset = NULL; exit(0) ; }
int main( int argc , char *argv[] ) { THD_3dim_dataset *dset=NULL; int iarg , verbose = -1 ; char *outbuf, *stmp=NULL; char *labelName = NULL; char *sbdelim = {"|"}; char *NAflag = {"NA"}; char *atrdelim = {"\t"}, *form=NULL; INFO_FIELDS sing[512]; int iis=0, N_sing = 0, isb=0, withhead = 0, itmp=0; int ip=0, needpair = 0, namelen=0, monog_pairs = 0; THD_3dim_dataset *tttdset=NULL, *dsetp=NULL; char *tempstr = NULL; int extinit = 0; float RL_AP_IS[6]; mainENTRY("3dinfo main") ; machdep() ; if( argc < 2) { Syntax(TXT,1) ; RETURN(0); } iarg = 1 ; while (iarg < argc && argv[iarg][0] == '-') { CHECK_HELP(argv[iarg],Syntax); if( strncmp(argv[iarg],"-verb" ,5) == 0 ){ verbose = 0; iarg++; continue; } else if( strncmp(argv[iarg],"-VERB" ,5) == 0 ){ verbose = 1; iarg++; continue; } else if( strncmp(argv[iarg],"-short",5) == 0 ){ verbose = -1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-header_line") == 0 || strcasecmp(argv[iarg],"-hdr") == 0 ){ withhead = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-monog_pairs") == 0 ){ monog_pairs = 1; iarg++; continue; } else if ( strncmp(argv[iarg],"-label2",7) == 0 ) { iarg++; if (iarg >= argc) ERROR_exit( "3dinfo needs an argument after -label2number\n"); labelName = malloc(sizeof(char) * 2048); strcpy(labelName, argv[iarg]); iarg++; continue; } else if( strcasecmp(argv[iarg],"-sb_delim") == 0) { iarg++; if (iarg >= argc) ERROR_exit( "3dinfo needs a string after -sb_delim\n"); sbdelim = argv[iarg]; iarg++; continue; } else if( strcasecmp(argv[iarg],"-NA_flag") == 0) { iarg++; if (iarg >= argc) ERROR_exit( "3dinfo needs a string after -NA_flag\n"); NAflag = argv[iarg]; iarg++; continue; } else if( strcasecmp(argv[iarg],"-atr_delim") == 0) { iarg++; if (iarg >= argc) ERROR_exit( "3dinfo needs a string after -atr_delim\n"); atrdelim = argv[iarg]; iarg++; continue; } else if( strcasecmp(argv[iarg],"-space") == 0) { sing[N_sing++] = DSET_SPACE; iarg++; continue; } else if( strcasecmp(argv[iarg],"-av_space") == 0) { sing[N_sing++] = AV_DSET_SPACE; iarg++; continue; } else if( strcasecmp(argv[iarg],"-gen_space") == 0) { sing[N_sing++] = DSET_GEN_SPACE; iarg++; continue; } else if( strcasecmp(argv[iarg],"-is_nifti") == 0) { sing[N_sing++] = IS_NIFTI; iarg++; continue; } else if( strcasecmp(argv[iarg],"-is_atlas") == 0) { sing[N_sing++] = IS_ATLAS; iarg++; continue; } else if( strcasecmp(argv[iarg],"-exists") == 0) { sing[N_sing++] = DSET_EXISTS; iarg++; continue; } else if( strcasecmp(argv[iarg],"-is_oblique") == 0) { sing[N_sing++] = IS_OBLIQUE; iarg++; continue; } else if( strcasecmp(argv[iarg],"-obliquity") == 0) { sing[N_sing++] = OBLIQUITY; iarg++; continue; } else if( strcasecmp(argv[iarg],"-handedness") == 0) { sing[N_sing++] = HANDEDNESS; iarg++; continue; } else if( strcasecmp(argv[iarg],"-prefix") == 0) { sing[N_sing++] = PREFIX; iarg++; continue; } else if( strcasecmp(argv[iarg],"-prefix_noext") == 0) { sing[N_sing++] = PREFIX_NOEXT; iarg++; continue; } else if( strcasecmp(argv[iarg],"-ni") == 0) { sing[N_sing++] = NI; iarg++; continue; } else if( strcasecmp(argv[iarg],"-nj") == 0) { sing[N_sing++] = NJ; iarg++; continue; } else if( strcasecmp(argv[iarg],"-nk") == 0) { sing[N_sing++] = NK; iarg++; continue; } else if( strcasecmp(argv[iarg],"-n4") == 0) { sing[N_sing++] = NI; sing[N_sing++] = NJ; sing[N_sing++] = NK; sing[N_sing++] = NV; iarg++; continue; } else if( strcasecmp(argv[iarg],"-Rextent") == 0) { sing[N_sing++] = EXTENT_R; iarg++; continue; } else if( strcasecmp(argv[iarg],"-Lextent") == 0) { sing[N_sing++] = EXTENT_L; iarg++; continue; } else if( strcasecmp(argv[iarg],"-Aextent") == 0) { sing[N_sing++] = EXTENT_A; iarg++; continue; } else if( strcasecmp(argv[iarg],"-Pextent") == 0) { sing[N_sing++] = EXTENT_P; iarg++; continue; } else if( strcasecmp(argv[iarg],"-Iextent") == 0) { sing[N_sing++] = EXTENT_I; iarg++; continue; } else if( strcasecmp(argv[iarg],"-Sextent") == 0) { sing[N_sing++] = EXTENT_S; iarg++; continue; } else if( strcasecmp(argv[iarg],"-extent") == 0) { sing[N_sing++] = EXTENT_R; sing[N_sing++] = EXTENT_L; sing[N_sing++] = EXTENT_A; sing[N_sing++] = EXTENT_P; sing[N_sing++] = EXTENT_I; sing[N_sing++] = EXTENT_S; iarg++; continue; } else if( strcasecmp(argv[iarg],"-di") == 0) { sing[N_sing++] = DI; iarg++; continue; } else if( strcasecmp(argv[iarg],"-dj") == 0) { sing[N_sing++] = DJ; iarg++; continue; } else if( strcasecmp(argv[iarg],"-dk") == 0) { sing[N_sing++] = DK; iarg++; continue; } else if( strcasecmp(argv[iarg],"-d3") == 0) { sing[N_sing++] = DI; sing[N_sing++] = DJ; sing[N_sing++] = DK; iarg++; continue; } else if( strcasecmp(argv[iarg],"-adi") == 0) { sing[N_sing++] = ADI; iarg++; continue; } else if( strcasecmp(argv[iarg],"-adj") == 0) { sing[N_sing++] = ADJ; iarg++; continue; } else if( strcasecmp(argv[iarg],"-adk") == 0) { sing[N_sing++] = ADK; iarg++; continue; } else if( strcasecmp(argv[iarg],"-ad3") == 0) { sing[N_sing++] = ADI; sing[N_sing++] = ADJ; sing[N_sing++] = ADK; iarg++; continue; } else if( strcasecmp(argv[iarg],"-voxvol") == 0) { sing[N_sing++] = VOXVOL; iarg++; continue; } else if( strcasecmp(argv[iarg],"-iname") == 0) { sing[N_sing++] = INAME; iarg++; continue; } else if( strcasecmp(argv[iarg],"-oi") == 0) { sing[N_sing++] = OI; iarg++; continue; } else if( strcasecmp(argv[iarg],"-oj") == 0) { sing[N_sing++] = OJ; iarg++; continue; } else if( strcasecmp(argv[iarg],"-ok") == 0) { sing[N_sing++] = OK; iarg++; continue; } else if( strcasecmp(argv[iarg],"-o3") == 0) { sing[N_sing++] = OI; sing[N_sing++] = OJ; sing[N_sing++] = OK; iarg++; continue; }else if( strcasecmp(argv[iarg],"-nt") == 0) { sing[N_sing++] = NT; iarg++; continue; } else if( strcasecmp(argv[iarg],"-nti") == 0) { sing[N_sing++] = NTI; iarg++; continue; } else if( strcasecmp(argv[iarg],"-nv") == 0) { sing[N_sing++] = NV; iarg++; continue; } else if( strcasecmp(argv[iarg],"-nvi") == 0) { sing[N_sing++] = NVI; iarg++; continue; } else if( strcasecmp(argv[iarg],"-ntimes") == 0) { sing[N_sing++] = NTIMES; iarg++; continue; } else if( strcasecmp(argv[iarg],"-max_node") == 0) { sing[N_sing++] = MAX_NODE; iarg++; continue; } else if( strcasecmp(argv[iarg],"-nijk") == 0) { sing[N_sing++] = NIJK; iarg++; continue; } else if( strcasecmp(argv[iarg],"-labeltable") == 0) { sing[N_sing++] = LTABLE; iarg++; continue; } else if( strcasecmp(argv[iarg],"-labeltable_as_atlas_points") == 0) { sing[N_sing++] = LTABLE_AS_ATLAS_POINT_LIST; iarg++; continue; } else if( strcasecmp(argv[iarg],"-atlas_points") == 0) { sing[N_sing++] = ATLAS_POINTS; iarg++; continue; } else if( strcasecmp(argv[iarg],"-fac") == 0) { sing[N_sing++] = FAC; iarg++; continue; } else if( strcasecmp(argv[iarg],"-datum") == 0) { sing[N_sing++] = DATUM; iarg++; continue; } else if( strcasecmp(argv[iarg],"-label") == 0) { sing[N_sing++] = LABEL; iarg++; continue; } else if( strcasecmp(argv[iarg],"-min") == 0) { sing[N_sing++] = MIN; iarg++; continue; } else if( strcasecmp(argv[iarg],"-max") == 0) { sing[N_sing++] = MAX; iarg++; continue; } else if( strcasecmp(argv[iarg],"-minus") == 0) { sing[N_sing++] = MINUS; iarg++; continue; } else if( strcasecmp(argv[iarg],"-maxus") == 0) { sing[N_sing++] = MAXUS; iarg++; continue; } else if( strcasecmp(argv[iarg],"-dmin") == 0) { sing[N_sing++] = DMIN; iarg++; continue; } else if( strcasecmp(argv[iarg],"-dmax") == 0) { sing[N_sing++] = DMAX; iarg++; continue; } else if( strcasecmp(argv[iarg],"-dminus") == 0) { sing[N_sing++] = DMINUS; iarg++; continue; } else if( strcasecmp(argv[iarg],"-dmaxus") == 0) { sing[N_sing++] = DMAXUS; iarg++; continue; } else if( strcasecmp(argv[iarg],"-TR") == 0) { sing[N_sing++] = TR; iarg++; continue; } else if( strcasecmp(argv[iarg],"-header_name") == 0) { sing[N_sing++] = HEADER_NAME; iarg++; continue; } else if( strcasecmp(argv[iarg],"-brick_name") == 0) { sing[N_sing++] = BRICK_NAME; iarg++; continue; } else if( strcasecmp(argv[iarg],"-history") == 0) { sing[N_sing++] = HISTORY; iarg++; continue; } else if( strcasecmp(argv[iarg],"-all_names") == 0) { sing[N_sing++] = ALL_NAMES; iarg++; continue; } else if( strcasecmp(argv[iarg],"-orient") == 0) { sing[N_sing++] = ORIENT; iarg++; continue; } else if( strcasecmp(argv[iarg],"-same_grid") == 0) { sing[N_sing++] = SAME_GRID; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-same_dim") == 0) { sing[N_sing++] = SAME_DIM; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-same_delta") == 0) { sing[N_sing++] = SAME_DELTA; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-same_orient") == 0) { sing[N_sing++] = SAME_ORIENT; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-same_center") == 0) { sing[N_sing++] = SAME_CENTER; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-same_obl") == 0) { sing[N_sing++] = SAME_OBL; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-slice_timing") == 0) { sing[N_sing++] = SLICE_TIMING; iarg++; continue; } else if( strcasecmp(argv[iarg],"-sval_diff") == 0) { sing[N_sing++] = SVAL_DIFF; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-val_diff") == 0) { sing[N_sing++] = VAL_DIFF; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-same_all_grid") == 0) { sing[N_sing++] = SAME_DIM; sing[N_sing++] = SAME_DELTA; sing[N_sing++] = SAME_ORIENT; sing[N_sing++] = SAME_CENTER; sing[N_sing++] = SAME_OBL; needpair = 1; iarg++; continue; } else if( strcasecmp(argv[iarg],"-id") == 0) { sing[N_sing++] = ID; iarg++; continue; } else if( strcasecmp(argv[iarg],"-smode") == 0) { sing[N_sing++] = SMODE; iarg++; continue; } else { ERROR_message("Option %s unknown", argv[iarg]); suggest_best_prog_option(argv[0], argv[iarg]); exit(1); } } if (N_sing == 0) { sing[N_sing++] = CLASSIC; } if (sing[iis] == CLASSIC) PRINT_VERSION("3dinfo") ; THD_allow_empty_dataset(1) ; /* 21 Mar 2007 */ if (iarg == argc) { ERROR_message("No dsets on command line? I have nothing to do.\n"); exit(1); } if (needpair && monog_pairs) needpair = 2; /* pair each couple separately */ if (needpair==2 && (argc-iarg) % 2) { ERROR_message("Using options requiring dset pairs but have odd number\n" "of dsets (%d) on command line.\n", (argc-iarg)); exit (1); } else if (needpair==1 && (argc-iarg) < 2) { ERROR_message("Using options requiring dset pairs but have less than\n" "two dsets (%d) on command line.\n", (argc-iarg)); exit (1); } ip = 0; for( ; iarg < argc ; iarg++ ){ if (ip == 0) { int kkk, nml; char *etr; namelen = 0; for (kkk=iarg; kkk<argc; ++kkk) { if ((etr = THD_trailname(argv[kkk],0))) { nml=strlen(etr); if (nml < 48 && nml > namelen) namelen = nml; } } if (namelen < 6) namelen = 6; if (withhead) { int havenew=0; for (iis = 0; iis < N_sing; ++iis) { if (sing[iis] != CLASSIC) { ++havenew; form = PrintForm(sing[iis], namelen, 1); /*fprintf(stderr,"ZSS: %d %s >%s<\n", sing[iis], Field_Names[sing[iis]], form);*/ fprintf(stdout, form, Field_Names[sing[iis]]); } if (havenew) { if (N_sing > 1 && iis < N_sing-1) fprintf(stdout,"%s",atrdelim); else fprintf(stdout,"\n"); } } } } if( argv[iarg][0] == '\0' ) continue ; /* bad filename */ set_obliquity_report(0); /* silence obliquity */ if (!needpair) { if (!(dset = load_3dinfo_dataset(argv[iarg]))) { /* exit(1); */ } } else { if (needpair == 2) { /* Crazy idea of comparing each pair separately */ if (ip % 2 == 0) { if (!(dset = load_3dinfo_dataset(argv[iarg] ))) { /* exit(1); */ } if (iarg+1==argc || argv[iarg+1][0] == '\0') { ERROR_message("Bad dset pair for %s\n", argv[iarg]); exit(1); } if (!(dsetp = load_3dinfo_dataset(argv[iarg+1] ))) { /* exit(1); */ } } else { /* swap the pair - this allows non pair requiring functions to work as before.*/ tttdset = dsetp; dsetp = dset; dset = tttdset; tttdset=NULL; } } else { /* always compare to very first dset */ if (ip==0) { if (!(dset = load_3dinfo_dataset(argv[iarg] ))) { /*exit(1);*/ } if (!(dsetp = load_3dinfo_dataset(argv[iarg+1] ))) { /*exit(1);*/ } } else if (ip==1) { /* switch order of first two */ tttdset = dsetp; dsetp = dset; /* now dsetp is the very first dset */ dset = tttdset; tttdset=NULL; } else { /* pair with very first, which is dsetp */ if (!(dset = load_3dinfo_dataset(argv[iarg] ))) { /*exit(1);*/ } } } } ++ip; if (0 && !dset) { /* allow for DSET_EXISTS option */ ERROR_exit("Should not get here"); } /* we should re-capture this per dataset 5 Feb 2019 [rickr] */ extinit = 0; for (iis = 0; iis < N_sing; ++iis) { if (!dset) { if (sing[iis] == CLASSIC) { if( dset == NULL ){ /* still not open? */ ERROR_exit("Can't open dataset %s\n", argv[iarg]) ; } } else if (sing[iis] != DSET_EXISTS && sing[iis] != INAME) { fprintf(stdout, "NO-DSET"); SPIT_DELIM(iis, N_sing, atrdelim); continue; } } switch (sing[iis]) { case CLASSIC: if (labelName == NULL ) /*** get and output info ***/ { outbuf = THD_dataset_info( dset , verbose ) ; if( outbuf != NULL ){ printf("\n") ; puts(outbuf) ; free(outbuf) ; outbuf = NULL ; } else { ERROR_exit("Can't get info for dataset %s",argv[iarg]) ; } } else /*** get and output label ***/ { int nval_per = dset->dblk->nvals; int foundLabel = 0; int ival=0; for (ival=0 ; ival < nval_per && !foundLabel; ival++ ) { if (strcmp(DSET_BRICK_LAB(dset,ival), labelName) == 0) { printf("%d\n", ival); foundLabel = 1; } } /* end of for (ival=0 ; ival < nval_per ; ival++ ) */ if (!foundLabel) printf("\n"); } THD_delete_3dim_dataset( dset , False ) ; free(labelName); break; case DSET_EXISTS: fprintf(stdout, "%d", dset ? 1:0); break; case DSET_SPACE: tempstr = THD_get_space(dset); if(tempstr==NULL) fprintf(stdout, "-----"); else fprintf(stdout, "%s", tempstr); break; case DSET_GEN_SPACE: tempstr = THD_get_generic_space(dset); if(tempstr==NULL) fprintf(stdout, "-----"); else fprintf(stdout, "%s", tempstr); break; case AV_DSET_SPACE: /* don't allow anything but the three AFNI views */ tempstr = THD_get_view_space(dset); if(tempstr==NULL) fprintf(stdout, "+orig"); else if (!strncasecmp(tempstr,"ORIG",4)) fprintf(stdout, "+orig"); else if (!strncasecmp(tempstr,"ACPC",4)) fprintf(stdout, "+acpc"); else if (!strncasecmp(tempstr,"TLRC",4)) fprintf(stdout, "+tlrc"); else /* shouldn't get here */ fprintf(stdout, "+orig"); break; case IS_NIFTI: if ( dset->dblk->diskptr && dset->dblk->diskptr->storage_mode == STORAGE_BY_NIFTI ) { fprintf(stdout,"1"); } else { fprintf(stdout,"0"); } break; case IS_ATLAS: if ( is_Dset_Atlasy(dset, NULL) ) { fprintf(stdout,"1"); } else { fprintf(stdout,"0"); } break; case IS_OBLIQUE: if (dset_obliquity(dset,NULL) > 0) { fprintf(stdout,"1"); } else { fprintf(stdout,"0"); } break; case HANDEDNESS: if (THD_handedness(dset) > 0) { fprintf(stdout,"R"); } else { fprintf(stdout,"L"); } break; case OBLIQUITY: fprintf(stdout,"%.3f", THD_compute_oblique_angle(dset->daxes->ijk_to_dicom_real, 0)); break; case PREFIX: form = PrintForm(sing[iis], namelen, 1); fprintf(stdout,form, DSET_PREFIX(dset)); break; case PREFIX_NOEXT: { form = PrintForm(sing[iis], namelen, 1); stmp=DSET_prefix_noext(dset); fprintf(stdout,form, stmp); free(stmp); stmp=NULL; } break; case HEADER_NAME: fprintf(stdout,"%s", dset->dblk->diskptr->header_name); break; case BRICK_NAME: fprintf(stdout,"%s", dset->dblk->diskptr->brick_name); break; case ALL_NAMES: THD_show_dataset_names(dset, "FOR_3DINFO", stdout); break; case HISTORY: stmp = tross_Get_History(dset); fprintf(stdout,"%s", stmp ? stmp:NAflag); if (stmp) free(stmp); stmp=NULL; break; case NI: fprintf(stdout,"%d", DSET_NX(dset)); break; case NJ: fprintf(stdout,"%d", DSET_NY(dset)); break; case NK: fprintf(stdout,"%d", DSET_NZ(dset)); break; case NIJK: fprintf(stdout,"%d", DSET_NVOX(dset)); break; case NTIMES: fprintf(stdout,"%d", DSET_NUM_TIMES(dset)); break; case MAX_NODE: DSET_MAX_NODE(dset,itmp); fprintf(stdout,"%d", itmp); break; case NT: case NV: fprintf(stdout,"%d", DSET_NVALS(dset)); break; case NTI: case NVI: fprintf(stdout,"%d", DSET_NVALS(dset)-1); break; case DI: fprintf(stdout,"%f", DSET_DX(dset)); break; case DJ: fprintf(stdout,"%f", DSET_DY(dset)); break; case DK: fprintf(stdout,"%f", DSET_DZ(dset)); break; case OI: fprintf(stdout,"%f", DSET_XORG(dset)); break; case OJ: fprintf(stdout,"%f", DSET_YORG(dset)); break; case OK: fprintf(stdout,"%f", DSET_ZORG(dset)); break; case ADI: fprintf(stdout,"%f", fabs(DSET_DX(dset))); break; case EXTENT_R: case EXTENT_L: case EXTENT_A: case EXTENT_P: case EXTENT_I: case EXTENT_S: { if (!extinit) { THD_dset_extent(dset, '-', RL_AP_IS); extinit = 1; } fprintf(stdout,"%f", RL_AP_IS[sing[iis]-EXTENT_R]); } break; case ADJ: fprintf(stdout,"%f", fabs(DSET_DY(dset))); break; case ADK: fprintf(stdout,"%f", fabs(DSET_DZ(dset))); break; case VOXVOL: fprintf(stdout,"%f", fabs(DSET_DX(dset))* fabs(DSET_DY(dset))*fabs(DSET_DZ(dset))); break; case INAME: fprintf(stdout,"%s", argv[iarg]); break; case LTABLE: { char *str; if ((str = Dtable_to_nimlstring(DSET_Label_Dtable(dset), "VALUE_LABEL_DTABLE"))) { fprintf(stdout,"%s", str); free(str); } else { fprintf(stdout,"NO_LABEL_TABLE"); } } break; case LTABLE_AS_ATLAS_POINT_LIST: { ATLAS_POINT_LIST *apl=NULL; if ((apl = label_table_to_atlas_point_list(DSET_Label_Dtable(dset)))) { atlas_list_to_niml(apl,NULL); free_atlas_point_list(apl); } else { fprintf(stdout,"NO_LABEL_TABLE"); } } break; case ATLAS_POINTS: { ATR_string *atr = THD_find_string_atr( dset->dblk, "ATLAS_LABEL_TABLE"); if (atr) { fprintf(stdout,"%s", atr->ch); } else { fprintf(stdout,"NO_APL"); } } break; case FAC: { for (isb=0; isb<DSET_NVALS(dset); ++isb) { fprintf(stdout,"%f%s", DSET_BRICK_FACTOR(dset,isb), (isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim); } break; } case DATUM: { for (isb=0; isb<DSET_NVALS(dset); ++isb) { fprintf(stdout,"%s%s", MRI_TYPE_name[DSET_BRICK_TYPE(dset,isb)], (isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim); } break; } case LABEL: { for (isb=0; isb<DSET_NVALS(dset); ++isb) { fprintf(stdout,"%s%s", DSET_BRICK_LABEL(dset,isb) ? DSET_BRICK_LABEL(dset,isb):NAflag, (isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim); } break; } case MIN: case MINUS: case MAX: case MAXUS: { float vv=0.0, min, max; for (isb=0; isb<DSET_NVALS(dset); ++isb) { if (!THD_subbrick_minmax(dset, isb, (sing[iis] == MINUS || sing[iis] == MAXUS) ? 0:1, &min, &max)) { fprintf(stdout,"%s%s", NAflag, (isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim); } else { if (sing[iis] == MINUS) vv = min; else if (sing[iis] == MAXUS) vv = max; else if (sing[iis] == MIN) vv = min; else if (sing[iis] == MAX) vv = max; fprintf(stdout,"%g%s", vv, (isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim); } } break; } case DMIN: case DMINUS: case DMAX: case DMAXUS: { float vv=0.0, min, max; if (!THD_dset_minmax(dset, (sing[iis] == DMINUS || sing[iis] == DMAXUS) ? 0:1, &min, &max)) { fprintf(stdout,"%s%s", NAflag, (isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim); } else { if (sing[iis] == DMINUS) vv = min; else if (sing[iis] == DMAXUS) vv = max; else if (sing[iis] == DMIN) vv = min; else if (sing[iis] == DMAX) vv = max; fprintf(stdout,"%g%s", vv, (isb == (DSET_NVALS(dset)-1)) ? "" : sbdelim); } break; } case TR: #if 0 fprintf(stdout,"%f", DSET_TR_SEC(dset)); #else fprintf(stdout,"%f", DSET_TR(dset)); #endif break; case ORIENT: { /* fprintf(stdout,"%c%c%c", * ORIENT_typestr[dset->daxes->xxorient][0], ... ); */ char ostr[4]; /* just to show 23 Jan 2013 [rickr] */ THD_fill_orient_str_3(dset->daxes, ostr); fprintf(stdout,"%3s", ostr); } break; case SAME_GRID: fprintf(stdout,"%d", !THD_dataset_mismatch( dset , dsetp )); break; case SAME_DIM: fprintf(stdout,"%d", !(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_DIMEN)); break; case SAME_DELTA: fprintf(stdout,"%d", !(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_DELTA)); break; case SAME_ORIENT: fprintf(stdout,"%d", !(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_ORIENT)); break; case SAME_CENTER: fprintf(stdout,"%d", !(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_CENTER)); break; case SAME_OBL: fprintf(stdout,"%d", !(THD_dataset_mismatch( dset , dsetp ) & MISMATCH_OBLIQ)); break; case SLICE_TIMING: /* 6 May 2013 [rickr] */ { if( DSET_HAS_SLICE_TIMING(dset) ) { DSET_UNMSEC(dset); /* make sure times are in seconds */ for (isb=0; isb<dset->taxis->nsl; ++isb) { fprintf(stdout,"%s%f", (isb > 0) ? sbdelim : "", dset->taxis->toff_sl[isb]); } } else { /* all slices times are at t=0.0 */ for (isb=0; isb<DSET_NZ(dset); ++isb) { fprintf(stdout,"%s%f", (isb > 0) ? sbdelim : "", 0.0); } } } break; case SVAL_DIFF: fprintf(stdout,"%f",THD_diff_vol_vals(dset, dsetp, 1)); break; case VAL_DIFF: fprintf(stdout,"%f",THD_diff_vol_vals(dset, dsetp, 0)); break; case ID: fprintf(stdout,"%s", DSET_IDCODE_STR(dset)); break; case SMODE: fprintf(stdout,"%s", DSET_STORAGE_MODE_STR(dset)); break; default: ERROR_message("Info field not set properly (%d)\n", sing[iis]); exit(1); } if (sing[iis] != CLASSIC) { SPIT_DELIM(iis, N_sing, atrdelim); } } } exit(0) ; }
char * POWER_main( PLUGIN_interface * plint ) { MCW_idcode * idc ; /* input dataset idcode */ THD_3dim_dataset * old_dset , * new_dsetD3 , * new_dsetA3, * new_dsetavgD3 ; /* input and output datasets */ char * new_prefix , * str , * namestr, * filename; /* strings from user */ int new_datum , ignore , nfft , ninp , /* control parameters */ old_datum , nuse , ntaper , ktbot, image_type, scale,OutputFlag ,numT,flip; float avFac; byte ** bptr = NULL ; /* one of these will be the array of */ short ** sptr = NULL ; /* pointers to input dataset sub-bricks */ float ** fptr = NULL ; /* (depending on input datum type) */ float * this = NULL ; /* array loaded from input dataset */ float ** foutD3 = NULL ; /* will be array of output floats */ float ** foutA3 = NULL ; /* will be array of output floats */ float ** foutavgD3 = NULL ; /* will be array of output floats */ float * tarD3 = NULL ; /* will be array of taper coefficients */ float * tarA3 = NULL ; /* will be array of taper coefficients */ float * taravgD3 = NULL ; /* will be array of taper coefficients */ /*float * flip;*/ float * numAv; float dfreq , pfact , phi , xr,xi , yr,yi ; float x0,x1 , y0,y1 , d0fac,d1fac ; int nfreq , nvox , perc , new_units ; int istr , ii,iip , ibot,itop , kk , icx ; /* temp variables */ new_prefix = (char *)calloc(100, sizeof(char)); filename = (char *)calloc(100, sizeof(char)); str = (char *)calloc(100, sizeof(char)); namestr = (char *)calloc(100, sizeof(char)); OutputFlag=0; /*--------------------------------------------------------------------*/ /*----- 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 */ namestr = DSET_PREFIX(old_dset) ; if( old_dset == NULL ) return "*************************\n" "Cannot find Input Dataset\n" "*************************" ; /*--------- go to second input line ---------*/ PLUTO_next_option(plint) ; filename = PLUTO_get_string(plint) ; /* get string item (the output prefix) */ sprintf(new_prefix,"%s%s",filename,"_D3"); if (strcmp(new_prefix,"_D3")==0){ OutputFlag=1; sprintf(new_prefix,"%s%s",namestr,"_D3"); } if (! PLUTO_prefix_ok(new_prefix) ){ PLUTO_popup_transient(plint,new_prefix); return "*************************\n" "Output filename already exists\n" "*************************" ; } PLUTO_popup_transient(plint,"Output file tags set automatically"); str = PLUTO_get_string(plint) ; /* get string item (the datum type) */ istr = PLUTO_string_index( str , /* find it in the list it came from */ NUM_TYPE_STRINGS , type_strings ) ; switch( istr ){ default: case 0: new_datum = MRI_float ; break ; break ; case 1: new_datum = MRI_byte ; break ; /* assign type of user's choice */ case 2: new_datum = MRI_short ; break ; case 3: new_datum = DSET_BRICK_TYPE( old_dset , 0 ) ; /* use old dataset type */ } /*--------- go to next input lines ---------*/ PLUTO_next_option(plint) ; /* skip to next line */ ignore = PLUTO_get_number(plint) ; /* get number item (ignore) */ ninp = DSET_NUM_TIMES(old_dset) ; /* number of values in input */ nuse = ninp; /* number of values to actually use */ nfreq=nuse; nfft=nuse; str = PLUTO_get_string(plint) ; /* get string item (the datum type) */ istr = PLUTO_string_index( str , /* find it in the list it came from */ NUM_TYPE_STRINGSX , type_stringsx ) ; switch( istr ){ default: case 0: image_type = 0; break; } PLUTO_next_option(plint) ; /* skip to next line */ scale = PLUTO_get_number(plint) ; /* get number item (scale) */ /*------------------------------------------------------*/ /*---------- At this point, the inputs are OK ----------*/ PLUTO_popup_meter( plint ) ; /* popup a progress meter */ /*--------- set up pointers to each sub-brick in the input dataset ---------*/ DSET_load( old_dset ) ; /* must be in memory before we get pointers to it */ old_datum = DSET_BRICK_TYPE( old_dset , 0 ) ; /* get old dataset datum type */ switch( old_datum ){ /* pointer type depends on input datum type */ default: return "******************************\n" "Illegal datum in Input Dataset\n" "******************************" ; /** create array of pointers into old dataset sub-bricks **/ /** Note that we skip the first 'ignore' sub-bricks here **/ /*--------- input is bytes ----------*/ /* voxel #i at time #k is bptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_byte: bptr = (byte **) malloc( sizeof(byte *) * nuse ) ; if( bptr == NULL ) return "Malloc\nFailure!\n [bptr]" ; for( kk=0 ; kk < nuse ; kk++ ) bptr[kk] = (byte *) DSET_ARRAY(old_dset,kk) ; break ; /*--------- input is shorts ---------*/ /* voxel #i at time #k is sptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_short: sptr = (short **) malloc( sizeof(short *) * nuse ) ; if( sptr == NULL ) return "Malloc\nFailure!\n [sptr]" ; for( kk=0 ; kk < nuse ; kk++ ) sptr[kk] = (short *) DSET_ARRAY(old_dset,kk) ; break ; /*--------- input is floats ---------*/ /* voxel #i at time #k is fptr[k][i] */ /* for i=0..nvox-1 and k=0..nuse-1. */ case MRI_float: fptr = (float **) malloc( sizeof(float *) * nuse ) ; if( fptr == NULL ) return "Malloc\nFailure!\n [fptr]" ; for( kk=0 ; kk < nuse ; kk++ ) fptr[kk] = (float *) DSET_ARRAY(old_dset,kk) ; break ; } /* end of switch on input type */ /*---- allocate space for 2 voxel timeseries and 1 FFT ----*/ this = (float *) malloc( sizeof(float) * nuse ) ; /* input */ tarD3 = (float *) malloc( sizeof(float) * MAX(nuse,nfreq) ) ; tarA3 = (float *) malloc( sizeof(float) * MAX(nuse,nfreq) ) ; taravgD3 = (float *) malloc( sizeof(float) * MAX(nuse,nfreq) ) ; /*flip = (float *)malloc( sizeof(float) * 1);*/ numAv = (float *)malloc( sizeof(float) * 1); numT=nuse-ignore; if (OutputFlag==1) sprintf(new_prefix,"%s%s",namestr,"_D3"); else sprintf(new_prefix,"%s%s",filename,"_D3"); new_dsetD3 = EDIT_empty_copy( old_dset ); { char * his = PLUTO_commandstring(plint) ; tross_Copy_History( old_dset , new_dsetD3 ) ; tross_Append_History( new_dsetD3 , his ) ; free(his) ; } /*-- edit some of its internal parameters --*/ ii = EDIT_dset_items( new_dsetD3 , ADN_prefix , new_prefix , /* filename prefix */ ADN_malloc_type , DATABLOCK_MEM_MALLOC , /* store in memory */ ADN_datum_all , new_datum , /* atomic datum */ ADN_nvals , numT , ADN_ntt ,numT, ADN_none ) ; if (OutputFlag==1) sprintf(new_prefix,"%s%s",namestr,"_A3"); else sprintf(new_prefix,"%s%s",filename,"_A3"); numT=nuse-ignore; new_dsetA3 = EDIT_empty_copy( old_dset ); { char * his = PLUTO_commandstring(plint) ; tross_Copy_History( old_dset , new_dsetA3 ) ; tross_Append_History( new_dsetA3 , his ) ; free(his) ; } /*-- edit some of its internal parameters --*/ ii = EDIT_dset_items( new_dsetA3 , ADN_prefix , new_prefix , /* filename prefix */ ADN_malloc_type , DATABLOCK_MEM_MALLOC , /* store in memory */ ADN_datum_all , new_datum , /* atomic datum */ ADN_nvals , numT, ADN_ntt ,numT, ADN_none ) ; if (OutputFlag==1) sprintf(new_prefix,"%s%s",namestr,"_avgD3"); else sprintf(new_prefix,"%s%s",filename,"_avgD3"); new_dsetavgD3 = EDIT_empty_copy( old_dset ); { char * his = PLUTO_commandstring(plint) ; tross_Copy_History( old_dset , new_dsetavgD3 ) ; tross_Append_History( new_dsetavgD3 , his ) ; free(his) ; } /*-- edit some of its internal parameters --*/ ii = EDIT_dset_items( new_dsetavgD3 , ADN_prefix , new_prefix , /* filename prefix */ ADN_malloc_type , DATABLOCK_MEM_MALLOC , /* store in memory */ ADN_datum_all , new_datum , /* atomic datum */ ADN_nvals , 1, ADN_ntt ,1, ADN_none ) ; /*---------------------- make a new dataset ----------------------*/ /*-------------------making a new dataset------------------------------------*/ /*------ make floating point output sub-bricks (only at the end will scale to byte or shorts) Output #ii at freq #kk will go into fout[kk][ii], for kk=0..nfreq-1, and for ii=0..nvox-1. ------*/ nvox = old_dset->daxes->nxx * old_dset->daxes->nyy * old_dset->daxes->nzz ; foutD3 = (float **) malloc( sizeof(float *) * nuse ) ; /* ptrs to sub-bricks */ foutA3 = (float **) malloc( sizeof(float *) * nuse ) ; /* ptrs to sub-bricks */ foutavgD3 = (float **) malloc( sizeof(float *) * 1 ) ; /* ptrs to sub-bricks */ if( foutD3 == NULL | foutA3 == NULL | foutavgD3 == NULL){ THD_delete_3dim_dataset( new_dsetD3 , False ) ; THD_delete_3dim_dataset( new_dsetA3 , False ) ; THD_delete_3dim_dataset( new_dsetavgD3 , False ) ; FREE_WORKSPACE ; return "Malloc\nFailure!\n [fout]" ; } for( kk=0 ; kk < nfreq ; kk++ ){ foutD3[kk] = (float *) malloc( sizeof(float) * nvox ) ; /* sub-brick # kk */ foutA3[kk] = (float *) malloc( sizeof(float) * nvox ) ; /* sub-brick # kk */ foutavgD3[0] = (float *) malloc( sizeof(float) * nvox ) ; /* sub-brick # kk */ if( foutD3[kk] == NULL ) break ; if( foutA3[kk] == NULL ) break ; if( foutavgD3[0] == NULL ) break ; } if( kk < nfreq ){ for( ; kk >= 0 ; kk-- ){ FREEUP(foutD3[kk]) ; FREEUP(foutA3[kk]) ; FREEUP(foutavgD3[0]) ; }/* free all we did get */ THD_delete_3dim_dataset( new_dsetD3 , False ) ; THD_delete_3dim_dataset( new_dsetA3 , False ) ; THD_delete_3dim_dataset( new_dsetavgD3 , False ) ; FREE_WORKSPACE ; return "Malloc\nFailure!\n [arrays]" ; } { char buf[128] ; ii = (nfreq * nvox * sizeof(float)) / (1024*1024) ; sprintf( buf , " \n" "*** 3D+time ASL a3/d3:\n" "*** Using %d MBytes of workspace,\n " "*** with # time points = %d\n" , ii,numT ) ; PLUTO_popup_transient( plint , buf ) ; } /*----------------------------------------------------*/ /*----- Setup has ended. Now do some real work. -----*/ /***** loop over voxels *****/ /* *(flip)=scale; */ *(numAv)= nuse-ignore; for( ii=0 ; ii < nvox ; ii ++ ){ /* time series */ switch( old_datum ){ case MRI_byte: for( kk=0 ; kk < nuse ; kk++ ){ this[kk] = bptr[kk][ii] ; } break ; case MRI_short: for( kk=0 ; kk < nuse ; kk++ ){ this[kk] = sptr[kk][ii] ; } break ; case MRI_float: for( kk=0 ; kk < nuse ; kk++ ){ this[kk] = fptr[kk][ii] ; } break ; } flip=scale*pow(-1,ignore+1); for( kk=0 ; kk < nuse-ignore ; kk++ ){ if (kk==nuse-1-ignore){ *(*(foutD3+kk)+ii)= flip*( *(this+kk+ignore-1)-*(this+kk+ignore) ); *(*(foutA3+kk)+ii)= 2*(*(this+kk+ignore-1)+*(this+kk+ignore)); } else if (kk==0){ /*D3 tag - control*/ *(*(foutD3+kk)+ii)= flip*( *(this+kk+ignore)-*(this+kk+ignore+1) ); *(*(foutA3+kk)+ii)= 2*(*(this+kk+ignore)+*(this+kk+ignore+1)); } else{ *(*(foutD3+kk)+ii)= flip*( 1*(*(this+kk+ignore-1))+-2*(*(this+kk+ignore))+1*(*(this+kk+ignore+1)) ); *(*(foutA3+kk)+ii)= ((*(this+kk+ignore-1))+2*(*(this+kk+ignore))+(*(this+kk+ignore+1))); flip=-1*flip; } } for( kk=0 ; kk < nuse-ignore ; kk++ ) *(*(foutavgD3)+ii)= *(*(foutavgD3)+ii)+(*(*(foutD3+kk)+ii)); *(*(foutavgD3)+ii)=*(*(foutavgD3)+ii) / (*(numAv)); } DSET_unload( old_dset ) ; /* don't need this no more */ switch( new_datum ){ /*** output is floats is the simplest: we just have to attach the fout bricks to the dataset ***/ case MRI_float: for( kk=0 ; kk < nuse-ignore ; kk++ ) EDIT_substitute_brick( new_dsetD3 , kk , MRI_float , foutD3[kk] ) ; break ; /*** output is shorts: we have to create a scaled sub-brick from fout ***/ case MRI_short:{ short * boutD3 ; float facD3 ; for( kk=0 ; kk < nuse-ignore ; kk++ ){ /* loop over sub-bricks */ /*-- get output sub-brick --*/ boutD3 = (short *) malloc( sizeof(short) * nvox ) ; if( boutD3 == NULL ){ fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ; EXIT(1) ; } /*-- find scaling and then scale --*/ facD3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutD3[kk] ) ; if( facD3 > 0.0 ){ facD3 = 32767.0 / facD3 ; EDIT_coerce_scale_type( nvox,facD3 , MRI_float,foutD3[kk] , MRI_short,boutD3 ) ; facD3 = 1.0 / facD3 ; } free( foutD3[kk] ) ; /* don't need this anymore */ /*-- put output brick into dataset, and store scale factor --*/ EDIT_substitute_brick( new_dsetD3 , kk , MRI_short , boutD3 ) ; tarD3 [kk] = facD3 ; } /*-- save scale factor array into dataset --*/ EDIT_dset_items( new_dsetD3 , ADN_brick_fac , tarD3 , ADN_none ) ; } break ; /*** output is bytes (byte = unsigned char) we have to create a scaled sub-brick from fout ***/ case MRI_byte:{ byte * boutD3 ; float facD3 ; for( kk=0 ; kk < nuse-ignore ; kk++ ){ /* loop over sub-bricks */ /*-- get output sub-brick --*/ boutD3 = (byte *) malloc( sizeof(byte) * nvox ) ; if( boutD3 == NULL ){ fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ; EXIT(1) ; } /*-- find scaling and then scale --*/ facD3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutD3[kk] ) ; if( facD3 > 0.0 ){ facD3 = 255.0 / facD3 ; EDIT_coerce_scale_type( nvox,facD3 , MRI_float,foutD3[kk] , MRI_byte,boutD3 ) ; facD3 = 1.0 / facD3 ; } free( foutD3[kk] ) ; /* don't need this anymore */ /*-- put output brick into dataset, and store scale factor --*/ EDIT_substitute_brick( new_dsetD3 , kk , MRI_byte , boutD3 ) ; tarD3 [kk] = facD3 ; } /*-- save scale factor array into dataset --*/ EDIT_dset_items( new_dsetD3 , ADN_brick_fac , tarD3 , ADN_none ) ; } break ; } /* end of switch on output data type */ switch( new_datum ){ /*** output is floats is the simplest: we just have to attach the fout bricks to the dataset ***/ case MRI_float: for( kk=0 ; kk < nuse-ignore ; kk++ ) EDIT_substitute_brick( new_dsetA3 , kk , MRI_float , foutA3[kk] ) ; break ; /*** output is shorts: we have to create a scaled sub-brick from fout ***/ case MRI_short:{ short * boutA3 ; float facA3 ; for( kk=0 ; kk < nuse-ignore ; kk++ ){ /* loop over sub-bricks */ /*-- get output sub-brick --*/ boutA3 = (short *) malloc( sizeof(short) * nvox ) ; if( boutA3 == NULL ){ fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ; EXIT(1) ; } /*-- find scaling and then scale --*/ facA3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutA3[kk] ) ; if( facA3 > 0.0 ){ facA3 = 32767.0 / facA3 ; EDIT_coerce_scale_type( nvox,facA3 , MRI_float,foutA3[kk] , MRI_short,boutA3 ) ; facA3 = 1.0 / facA3 ; } free( foutA3[kk] ) ; /* don't need this anymore */ /*-- put output brick into dataset, and store scale factor --*/ EDIT_substitute_brick( new_dsetA3 , kk , MRI_short , boutA3 ) ; tarA3[kk] = facA3 ; } /*-- save scale factor array into dataset --*/ EDIT_dset_items( new_dsetA3 , ADN_brick_fac , tarA3 , ADN_none ) ; } break ; /*** output is bytes (byte = unsigned char) we have to create a scaled sub-brick from fout ***/ case MRI_byte:{ byte * boutA3 ; float facA3 ; for( kk=0 ; kk < nuse-ignore ; kk++ ){ /* loop over sub-bricks */ /*-- get output sub-brick --*/ boutA3 = (byte *) malloc( sizeof(byte) * nvox ) ; if( boutA3 == NULL ){ fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ; EXIT(1) ; } /*-- find scaling and then scale --*/ facA3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutA3[kk] ) ; if( facA3 > 0.0 ){ facA3 = 255.0 / facA3 ; EDIT_coerce_scale_type( nvox,facA3 , MRI_float,foutA3[kk] , MRI_byte,boutA3 ) ; facA3 = 1.0 / facA3 ; } free( foutA3[kk] ) ; /* don't need this anymore */ /*-- put output brick into dataset, and store scale factor --*/ EDIT_substitute_brick( new_dsetA3 , kk , MRI_byte , boutA3 ) ; tarA3[kk]= facA3 ; } /*-- save scale factor array into dataset --*/ EDIT_dset_items( new_dsetA3 , ADN_brick_fac , tarA3 , ADN_none ) ; } break ; } /* end of switch on output data type */ switch( new_datum ){ case MRI_float:{ EDIT_substitute_brick( new_dsetavgD3 , 0 , MRI_float , foutavgD3[0] ) ; } break ; case MRI_short:{ short * boutavgD3 ; float facavgD3 ; boutavgD3 = (short *) malloc( sizeof(short) * nvox ) ; if( boutavgD3 == NULL ){ fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ; EXIT(1) ; } facavgD3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutavgD3[0] ) ; if( facavgD3 > 0.0 ){ facavgD3 = 32767.0 / facavgD3 ; EDIT_coerce_scale_type( nvox,facavgD3 , MRI_float,foutavgD3[0] , MRI_short,boutavgD3 ) ; facavgD3 = 1.0 / facavgD3 ; } EDIT_substitute_brick( new_dsetavgD3 , 0 , MRI_short , boutavgD3 ) ; taravgD3[0] = facavgD3 ; EDIT_dset_items( new_dsetavgD3 , ADN_brick_fac , taravgD3 , ADN_none ) ; } break ; case MRI_byte:{ byte * boutavgD3 ; float facavgD3 ; boutavgD3 = (byte *) malloc( sizeof(byte) * nvox ) ; if( boutavgD3 == NULL ){ fprintf(stderr,"\nFinal malloc error in plug_power!\n\a") ; EXIT(1) ; } facavgD3 = MCW_vol_amax( nvox,1,1 , MRI_float , foutavgD3[0] ) ; if( facavgD3 > 0.0 ){ facavgD3 = 255.0 / facavgD3 ; EDIT_coerce_scale_type( nvox,facavgD3 , MRI_float,foutavgD3[0] , MRI_byte,boutavgD3 ) ; facavgD3 = 1.0 / facavgD3 ; } EDIT_substitute_brick( new_dsetavgD3 , 0 , MRI_byte , boutavgD3 ) ; taravgD3[0]= facavgD3 ; EDIT_dset_items( new_dsetavgD3 , ADN_brick_fac , taravgD3 , ADN_none ) ; } break ; } /* endasda of switch on output data type */ /*-------------- Cleanup and go home ----------------*/ PLUTO_add_dset( plint , new_dsetD3 , DSET_ACTION_NONE ) ; PLUTO_add_dset( plint , new_dsetA3 , DSET_ACTION_NONE ) ; PLUTO_add_dset( plint , new_dsetavgD3 , DSET_ACTION_NONE ) ; FREE_WORKSPACE ; free(numAv); return NULL ; /* null string returned means all was OK */ }
/*! \brief out_set = thd_polyfit( in_set, mask, polorder, prefix, verb); fits a polynomial model of order polorder to the time series of voxels in in_set \param in_set (THD_3dim_dataset* ) An AFNI dset pointer to input data \param mask (byte *) if mask is not NULL then voxel i will be processed if mask[i] != 0. if mask is NULL then all voxels are processed. \param polorder (int) polynomial order \param prefix (char *) prefix of output dset \param verb (int) verbosity flag \return out_set (THD_3dim_dataset* ) Dset containing polynomial fits. */ THD_3dim_dataset *thd_polyfit(THD_3dim_dataset *in_set, byte *mask, int polorder, char *prefix, int verb) { int i=0, j=0, nl=0, k=0, posi=0, posj=0, posk=0, nrow=0, ncol = 0; double xi=0.0, yi=0.0, yy=0.0, ei=0.0, sumsq=0.0, med=0.0; gsl_matrix *X=NULL, *cov=NULL; gsl_vector *y=NULL, *w=NULL, *c=NULL; MRI_IMAGE *im = NULL; THD_3dim_dataset *out_set=NULL; double *dar = NULL; float *cbuf=NULL; float *dvec = NULL; gsl_multifit_linear_workspace *work=NULL; ENTRY("thd_polyfit"); /* prepare output */ out_set = EDIT_empty_copy(in_set) ; EDIT_dset_items( out_set , ADN_nvals , polorder , ADN_ntt , polorder , ADN_datum_all , MRI_float , ADN_brick_fac , NULL , ADN_prefix , prefix ? prefix : "OMG!" , ADN_none ) ; for( j=0 ; j < polorder ; j++ ) /* create empty bricks to be filled below */ EDIT_substitute_brick( out_set , j , MRI_float , NULL ) ; /* do the fitting */ if (verb) fprintf (stderr,"Now fitting...\n"); ncol = DSET_NVALS(in_set); nrow = DSET_NVOX(in_set); X = gsl_matrix_alloc (ncol, polorder); y = gsl_vector_alloc (ncol); c = gsl_vector_alloc (polorder); cov = gsl_matrix_alloc (polorder, polorder); for (i = 0; i < ncol; i++) { xi = i+1; gsl_matrix_set (X, i, 0, 1.0); gsl_matrix_set (X, i, 1, xi); gsl_matrix_set (X, i, 2, xi*xi); gsl_matrix_set (X, i, 3, xi*xi*xi); gsl_matrix_set (X, i, 4, xi*xi*xi*xi); // printf ("%lg ",xi); } /*make header printf ("matrvola\n"); ZSS: By adding # to the text line, I made the output file be a .1D format */ if (verb > 1) fprintf(stdout, "#%s_0\t%s_1\t%s_2\t%s_3\t%s_4\n", DSET_PREFIX(in_set),DSET_PREFIX(in_set), DSET_PREFIX(in_set),DSET_PREFIX(in_set), DSET_PREFIX(in_set)); // go by lines - signatures /* pre-allocate, I think this should be just fine, there should be no need to reinitialize work all the time */ work = gsl_multifit_linear_alloc (ncol, polorder); dvec = (float * )malloc(sizeof(float)*ncol) ; /* array to hold signature */ cbuf = (float *)malloc(sizeof(float)*polorder) ; /* array to hold fit */ for (nl=0; nl<nrow; ++nl) { if (!mask || mask[nl]) { posi = -1; posj = -1; posk = -1; THD_extract_array( nl , in_set , 0 , dvec ) ; /*get signature from voxel */ for (k = 0; k < ncol; k++) { gsl_vector_set (y, k, dvec[k]); } gsl_multifit_linear (X, y, c, cov, &sumsq, work); /* printf ( "\n # best fit: Y = %g + %g X + %g X^2 +%g X^3 + %g X^4\n", C(0), C(1), C(2), C(3), C(4)); printf ("# sumsq = %g\n", sumsq); */ for (i=0;i<polorder;++i) cbuf[i] = (float)C(i); THD_insert_series( nl , out_set , polorder , MRI_float , cbuf , 1 ) ; /* stick result in output */ if (verb > 1) fprintf (stdout, "%11g\t%11g\t%11g\t%11g\t%11g\n", C(0), C(1), C(2), C(3), C(4)); /* printf ("# covariance matrix:\n"); printf ("[ %+.5e, %+.5e, %+.5e \n", COV(0,0), COV(0,1), COV(0,2)); printf (" %+.5e, %+.5e, %+.5e \n", COV(1,0), COV(1,1), COV(1,2)); printf (" %+.5e, %+.5e, %+.5e ]\n", COV(2,0), COV(2,1), COV(2,2)); printf ("# chisq = %g\n", chisq); */ } } gsl_multifit_linear_free (work); work = NULL; free(dvec); dvec = NULL; free(cbuf); cbuf = NULL; gsl_vector_free (y); gsl_vector_free (c); gsl_matrix_free (cov); gsl_matrix_free (X); //gsl_vector_free (w); free(dvec); dvec = NULL; RETURN(out_set); }
/*! Put some help like for function thd_polyfit */ int thd_Acluster ( THD_3dim_dataset *in_set, byte *mask, int nmask, THD_3dim_dataset **clust_set, THD_3dim_dataset **dist_set, OPT_KMEANS oc ) { int ii, nl, nc; double **D=NULL, **distmatrix=NULL; /* this double business is a waste of memory, at least for D..*/ int ncol = -1; float *dvec=NULL; int* clusterid = NULL; short *sc = NULL; ENTRY("thd_Acluster"); if (!clust_set || *clust_set) { fprintf(stderr, "ERROR: output volume pointer pointers must point to NULL\n"); RETURN(0); } if (!mask) nmask = DSET_NVOX(in_set); ncol = DSET_NVALS(in_set); if (ncol < DSET_NUM_TIMES(in_set)) ncol = DSET_NUM_TIMES(in_set); if (oc.verb) { ININFO_message("Have %d/%d voxels to process " "with %d dimensions per voxel.\n", nmask, DSET_NVOX(in_set), ncol); } /* Create data matrix */ D = (double **)calloc(sizeof(double*), nmask); for (ii=0;ii<(nmask);++ii) { if (!(D[ii] = (double *)calloc(sizeof(double), ncol))) { fprintf(stderr,"ERROR: Failed while allocating %dx%d double matrix\n", nmask, ncol); RETURN(0); } } dvec = (float * )malloc(sizeof(float)*ncol) ; /* array to hold series */ if (oc.verb) { ININFO_message("Filling D(%dx%d) (mask=%p).\n", nmask, ncol, mask); } ii = 0; for (nl=0; nl<DSET_NVOX(in_set); ++nl) { if (!mask || mask[nl]) { THD_extract_array( nl , in_set , 0 , dvec ) ; for (nc=0; nc<ncol; ++nc) D[ii][nc] = dvec[nc]; ++ii; } } /* allocate for answer arrays */ if (!(clusterid = (int *)calloc(sizeof(int), nmask))) { fprintf(stderr,"ERROR: Failed to allocate for clusterid\n"); RETURN(0); } /* now do the clustering (ANDREJ: I do not know why the counting skipped 1st row and 1st col....) */ if (oc.k > 0) { if (oc.verb) { ININFO_message("Going to cluster: k=%d, r=%d\n" "distmetric %c, jobname %s\n", oc.k, oc.r, oc.distmetric, oc.jobname); } example_kmeans( nmask, ncol, D, oc.k, oc.r, oc.distmetric, oc.jobname, clusterid); } else if (oc.kh > 0) { if (oc.verb) { ININFO_message("Going to h cluster: kh=%d\n" "jobname %s\n", oc.kh, oc.jobname); } if ((distmatrix = example_distance_gene(nmask, ncol, D))) { example_hierarchical( nmask, ncol, D, oc.jobname, oc.kh, distmatrix, clusterid); /* YOU SHOULD FREE distmatrix here ...*/ } else { ERROR_message("Failed to create distmatrix"); RETURN(0); } } else { ERROR_message("Bad option selection"); RETURN(0); } /* create output datasets, if required*/ *clust_set = EDIT_empty_copy(in_set) ; EDIT_dset_items( *clust_set , ADN_nvals , 1 , ADN_ntt , 1 , ADN_datum_all , MRI_short , ADN_brick_fac , NULL , ADN_prefix , "OML!" , ADN_none ) ; /* MRI_float */ if (oc.verb) { ININFO_message("loading results into %s\n", DSET_PREFIX(*clust_set)); } /* transfer ints in clusterid to shorts array */ sc = (short *)calloc(sizeof(short),DSET_NVOX(in_set)); ii = 0; for (nl=0; nl<DSET_NVOX(in_set); ++nl) { if (!mask || mask[nl]) { sc[nl] = (short)clusterid[ii]+1; ++ii; } } free(clusterid); clusterid = NULL; EDIT_substitute_brick( *clust_set , 0 , MRI_short , sc ) ; sc = NULL; /* array now in brick */ if (oc.verb) { ININFO_message("Freedom"); } if (dvec) free(dvec); dvec=NULL; // To free D for (ii=0;ii<nmask;++ii) { if (D[ii]) free(D[ii]); } free(D); D = NULL; RETURN(1); }
int *THD_unique_vals( THD_3dim_dataset *mask_dset , int miv, int *n_unique , byte *cmask) { int nvox , ii, *unq = NULL, *vals=NULL; *n_unique = 0; unq = NULL ; if( !ISVALID_DSET(mask_dset) || miv < 0 || miv >= DSET_NVALS(mask_dset) ) { fprintf(stderr,"** Bad mask_dset or sub-brick index.\n"); return (unq) ; } nvox = DSET_NVOX(mask_dset) ; DSET_load(mask_dset) ; if( !DSET_LOADED(mask_dset) ) return (unq) ; if (!is_integral_sub_brick (mask_dset, miv, 0)) { fprintf(stderr,"** Sub-brick %d of %s is not of an integral data type.\n", miv, DSET_PREFIX(mask_dset) ? DSET_PREFIX(mask_dset):"NULL"); return (unq) ; } vals = (int *)malloc(sizeof(int)*nvox); if (!vals) { fprintf(stderr,"** Failed to allocate.\n"); return (unq) ; } switch( DSET_BRICK_TYPE(mask_dset,miv) ){ default: fprintf(stderr,"** Bad dset type for unique operation.\n" "Only integral valued dsets are allowed.\n"); DSET_unload(mask_dset) ; if (vals) free(vals); return (unq) ; case MRI_short:{ short *mar = (short *) DSET_ARRAY(mask_dset,miv) ; if (cmask) { for( ii=0 ; ii < nvox ; ii++ ) if (cmask[ii]) vals[ii] = (int)(mar[ii]); else vals[ii] = 0; } else { for( ii=0 ; ii < nvox ; ii++ ) vals[ii] = (int)(mar[ii]); } } break ; case MRI_byte:{ byte *mar = (byte *) DSET_ARRAY(mask_dset,miv) ; if (cmask) { for( ii=0 ; ii < nvox ; ii++ ) if (cmask[ii]) vals[ii] = (int)(mar[ii]); else vals[ii] = 0; } else { for( ii=0 ; ii < nvox ; ii++ ) vals[ii] = (int)(mar[ii]); } } break ; case MRI_float:{ float *mar = (float *) DSET_ARRAY(mask_dset,miv) ; if (cmask) { for( ii=0 ; ii < nvox ; ii++ ) if (cmask[ii]) vals[ii] = (int)(mar[ii]); else vals[ii] = 0; } else { for( ii=0 ; ii < nvox ; ii++ ) vals[ii] = (int)(mar[ii]); } } break ; } /* unique */ unq = UniqueInt (vals, nvox, n_unique, 0 ); free(vals); vals = NULL; return (unq) ; }
static char * DELAY_main( PLUGIN_interface * plint ) { hilbert_data_V2 uda,*ud; MRI_IMAGE * tsim; MCW_idcode * idc ; /* input dataset idcode */ THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */ char *tmpstr , * str , *nprfxstr; /* strings from user */ int ntime, nvec ,nprfx, i; float * vec , fs , T ; /* Allocate as much character space as Bob specifies in afni.h + a bit more */ tmpstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char)); nprfxstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char)); if (tmpstr == NULL || nprfxstr == NULL) return "********************\n" "Could not Allocate\n" "a teeni weeni bit of\n" "Memory ! \n" "********************\n"; ud = &uda; /* ud now points to an allocated space */ ud->errcode = 0; /*reset error flag */ /*--------------------------------------------------------------------*/ /*----- 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" "*************************" ; ud->dsetname = DSET_FILECODE (old_dset); ud->nsamp = DSET_NUM_TIMES (old_dset); ud->Navg = 1 ; /* Navg does not play a role for the p value, averaging increases sensitivity */ ud->Nort = PLUTO_get_number(plint) ; /* Should be two by default, for mean and linear trend */ ud->Nfit = 2 ; /* Always 2 for phase and amplitude for this plugin */ /*--------- go to 2nd input line, input time series ---------*/ PLUTO_next_option(plint) ; tsim = PLUTO_get_timeseries(plint); if (tsim == NULL) return "No Timeseries Input"; ud->ln = (int)tsim -> nx; /* number of points in each vector */ nvec = tsim -> ny; /* number of vectors */ ud->rvec = (float *) MRI_FLOAT_PTR(tsim); /* vec[i+j*nx] = ith point of jth vector */ /* for i=0 .. ntime-1 and j=0 .. nvec-1 */ if (is_vect_null (ud->rvec,ud->ln) == 1) /* check if ref vect is all zeroes */ { return "Reference vector is all zeros"; } ud->refname = tsim->name; ud->ignore = PLUTO_get_number(plint) ; /* get number item */ str = PLUTO_get_string(plint) ; ud->Dsamp = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ; /*--------- go to 3rd input line, sampling frequency, and stimulus period ---------*/ PLUTO_next_option(plint) ; ud->fs = PLUTO_get_number(plint) ; /* get number item */ ud->T = PLUTO_get_number(plint) ; /* get number item */ ud->co = PLUTO_get_number(plint) ; /* get number item */ str = PLUTO_get_string(plint) ; ud->biasrem = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ; /*--------- go to 4th input line, delay units and wrp option---------*/ PLUTO_next_option(plint) ; ud->Nseg = (int)PLUTO_get_number(plint) ; /* get number item */ ud->Pover = (int)PLUTO_get_number(plint) ; /* get number item */ str = PLUTO_get_string(plint) ; /* get string item (the method) */ ud->unt = (int)PLUTO_string_index( str , /* find it in list it is from */ NUM_METHOD_STRINGS , method_strings ) ; str = PLUTO_get_string(plint) ; ud->wrp = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ) ; /*--------- go to 5th input line Output prefix ---------*/ PLUTO_next_option(plint) ; ud->new_prefix = PLUTO_get_string(plint) ; /* get string item (the output prefix) */ /* check to see if the field is empty */ if (ud->new_prefix == NULL) nprfx = 0; else nprfx = 1; /* check if the size is larger than 0. I did not want to check for this unless it's allocated */ if (nprfx == 1 && (int)strlen (ud->new_prefix) == 0) nprfx = 0; if (nprfx == 0) /* now create the new name and make new_prefix point to it */ { sprintf (nprfxstr,"%s.DEL",DSET_PREFIX (old_dset)); ud->new_prefix = nprfxstr; /*printf ("New prefix is set to be : %s\n\a",ud->new_prefix);*/ } if( ! PLUTO_prefix_ok(ud->new_prefix) ) /* check if it is OK */ return "************************\n" "Output Prefix is illegal\n" "************************" ; str = PLUTO_get_string(plint) ; /* write delays to file ? */ ud->out = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ); ud->strout = PLUTO_get_string(plint) ; /* strout is for the outiflename, which will be used after the debugging section */ if (ud->strout == NULL) /* if no output name is given, use the new_prefix */ {ud->strout = ud->new_prefix;} else { if((int)strlen (ud->strout) == 0) ud->strout = ud->new_prefix; } str = PLUTO_get_string(plint) ; ud->outts = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ); /* ------------------Done with user parameters ---------------------------- */ ud->nxx = (int)old_dset->daxes->nxx; /* get data set dimensions */ ud->nyy = (int)old_dset->daxes->nyy; ud->nzz = (int)old_dset->daxes->nzz; /* No need for users to set these options ...*/ ud->dtrnd = 0; if (ud->ln != (ud->nsamp - ud->ignore)) { ud->errcode = ERROR_BADLENGTH; return "***************************\n" "Bad time series length \n" "Check reference time series\n" " or the ignore parameter \n" "***************************\n"; } if ((ud->unt < 0) || (ud->unt > 2)) /* unt error Check */ { ud->errcode = ERROR_WRONGUNIT; return "***********************\n" " internal error: (ziad)\n" "unt values out of bound\n" "***********************\n"; /*unt must be between 0 and 2 */ } if ((ud->wrp < 0) || (ud->wrp > 1)) /* wrp error Check */ { ud->errcode = ERROR_WARPVALUES; return "***********************\n" " internal error: (ziad)\n" "wrp values out of bound\n" "***********************\n"; /* wrp must be between 0 and 1*/ } if (ud->fs < 0.0) { /* fs error Check */ ud->errcode = ERROR_FSVALUES; return "***********************\n" " internal error: (ziad)\n" "fs value is negative !\n" "***********************\n"; /* fs must be >= 0*/ } if (ud->T < 0.0) { /* T error Check */ ud->errcode = ERROR_TVALUES; return "***********************\n" " internal error: (ziad)\n" "T value is negative !\n" "***********************\n"; /*T must be >= 0 */ } if ((ud->T == 0.0) && (ud->unt > 0)) /* unt error Check */ { ud->errcode = ERROR_TaUNITVALUES; return "***********************\n" " internal error: (ziad)\n" "T and unt val. mismatch\n" "***********************\n"; /*T must be specified, and > 0 in order to use polar units*/ } if ((ud->wrp == 1) && (ud->T == 0.0)) /* wrp error Check */ { ud->errcode = ERROR_TaWRAPVALUES; return "***********************\n" " internal error: (ziad)\n" "wrp and T val. mismatch\n" "***********************\n"; /*T must be specified, and > 0 in order to use polar warp*/ } if ((ud->out == NOPE) && (ud->outts == YUP)) { ud->errcode = ERROR_OUTCONFLICT; return"***********************\n" "error: \n" "Write flag must be on\n" "to use Write ts\n" "***********************\n"; } /* Open the logfile, regardless of the ascii output files */ sprintf ( tmpstr , "%s.log" , ud->strout); ud->outlogfile = fopen (tmpstr,"w"); if (ud->out == YUP) /* open outfile */ { ud->outwrite = fopen (ud->strout,"w"); if (ud->outts == YUP) { sprintf ( tmpstr , "%s.ts" , ud->strout); ud->outwritets = fopen (tmpstr,"w"); } if ((ud->outwrite == NULL) || (ud->outlogfile == NULL) ||\ (ud->outwritets == NULL && ud->outts == YUP) ) { ud->errcode = ERROR_FILEOPEN; return "***********************\n" "Could Not Write Outfile\n" "***********************\n"; } } /* Write out user variables to Logfile */ write_ud (ud); /* writes user data to a file */ /*show_ud (ud,0); */ /* For some debugging */ /*------------- ready to compute new dataset -----------*/ new_dset = MAKER_4D_to_typed_fbuc ( old_dset , /* input dataset */ ud->new_prefix , /* output prefix */ -1, /* negative value indicating data type is like original brick */ ud->ignore , /* ignore count */ 1 , /* detrend = ON Let BOB do it*/ NBUCKETS, /*Number of values at each voxel*/ DELAY_tsfuncV2 , /* timeseries processor (bucket version)*/ (void *)ud, /* data for tsfunc */ NULL, 0 ) ; /* Setup the label, keywords and types of subbricks */ i = 0; while (i < NBUCKETS) { switch (i) { case DELINDX: /* delay value in results vector */ EDIT_BRICK_LABEL (new_dset,i,"Delay"); EDIT_BRICK_ADDKEY (new_dset,i,"D"); ++i; break; case COVINDX: /* covariance value in results vector */ EDIT_BRICK_LABEL (new_dset,i,"Covariance"); EDIT_BRICK_ADDKEY (new_dset,i,"I"); ++i; break; case COFINDX: /* cross correlation coefficient value in results vector */ EDIT_BRICK_LABEL (new_dset,i,"Corr. Coef."); EDIT_BRICK_ADDKEY (new_dset,i,"r"); /* Here you must modify either ud->Nfit or ud->Nort or most likely ud->nsamp based on ud->Navg */ EDIT_BRICK_TO_FICO (new_dset,i,ud->nsamp - ud->ignore,ud->Nfit,ud->Nort); ++i; break; case VARINDX: /* FMRI time course variance value in results vector */ EDIT_BRICK_LABEL (new_dset,i,"Variance"); EDIT_BRICK_ADDKEY (new_dset,i,"S2"); ++i; break; default : return "*********************\n" "Internal Error (ziad)\n" " Bad i value \n" "*********************\n"; break; } } if (!AFNI_noenv("AFNI_AUTOMATIC_FDR")) { THD_create_all_fdrcurves( new_dset ); } PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ; if (ud->out == YUP) /* close outfile and outlogfile*/ { fclose (ud->outlogfile); fclose (ud->outwrite); if (ud->outts == YUP) fclose (ud->outwritets); } else { if (ud->outlogfile != NULL) fclose (ud->outlogfile); /* close outlogfile */ } free (tmpstr); free (nprfxstr); return NULL ; /* null string returned means all was OK */ }
static char * EXTRACT_main( PLUGIN_interface * plint ) { extract_data uda,*ud; MRI_IMAGE * tsim; MCW_idcode * idc ; /* input dataset idcode */ THD_3dim_dataset * old_dset , * new_dset ; /* input and output datasets */ char *tmpstr , * str , *nprfxstr; int ntime, nvec ,nprfx, Err=0 , itmp; float * vec , fs , T ; char * tag; /* plugin option tag */ /* Allocate as much character space as Bob specifies in afni.h + a bit more */ tmpstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char)); nprfxstr = (char *) calloc (PLUGIN_MAX_STRING_RANGE+10,sizeof(char)); if (tmpstr == NULL || nprfxstr == NULL) return "********************\n" "Could not Allocate\n" "a teeni weeni bit of\n" "Memory ! Go complain\n" "to yer Mamma ! \n" "********************\n"; ud = &uda; /* ud now points to an allocated space */ ud->errcode = 0; /*reset error flag */ /*--------------------------------------------------------------------*/ /*----- Check inputs from AFNI to see if they are reasonable-ish -----*/ /*--------- go to first input line ---------*/ tag = PLUTO_get_optiontag(plint) ; if (tag == NULL) { return "************************\n" "Bad 1st line option \n" "************************" ; } 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" "*************************" ; ud->dsetname = DSET_FILECODE (old_dset); ud->ignore = PLUTO_get_number(plint) ; /* get number item */ str = PLUTO_get_string(plint) ; ud->dtrnd = (int)PLUTO_string_index( str , NUM_YN_STRINGS , yn_strings ); /*--------- loop over ramining options ---------*/ ud->iloc = -1; ud->xloc = -1; ud->yloc = -1; ud->zloc = -1; do { tag = PLUTO_get_optiontag(plint) ; if (tag == NULL) break; if (strcmp (tag, "Mask") == 0) { ud->strin = PLUTO_get_string(plint) ; ud->ncols = PLUTO_get_number(plint) ; ud->pass = PLUTO_get_number(plint) ; ud->fail = 0; /* Set voxels that don't make it to 0 */ continue; } if (strcmp (tag, "Index") == 0) { ud->iloc = PLUTO_get_number(plint) ; /* get number item */ continue; } if (strcmp (tag, "XYZ") == 0) { ud->xloc = PLUTO_get_number(plint) ; /* get number item */ ud->yloc = PLUTO_get_number(plint) ; /* get number item */ ud->zloc = PLUTO_get_number(plint) ; /* get number item */ continue; } if (strcmp (tag, "Output") == 0) { ud->new_prefix = PLUTO_get_string(plint) ; /* get string item (the output prefix) */ /* check to see if the field is empty */ if (ud->new_prefix == NULL) nprfx = 0; else nprfx = 1; /* check if the size is larger than 0. I did not want to check for this unless it's allocated */ if (nprfx == 1 && (int)strlen (ud->new_prefix) == 0) nprfx = 0; if (nprfx == 0) /* now create the new name and make new_prefix point to it */ { sprintf (nprfxstr,"%s.XTRCT",DSET_PREFIX (old_dset)); ud->new_prefix = nprfxstr; /*printf ("New prefix is set to be : %s\n\a",ud->new_prefix);*/ } if( ! PLUTO_prefix_ok(ud->new_prefix) ) /* check if it is OK */ return "************************\n" "Output Prefix is illegal\n" "************************" ; ud->strout = PLUTO_get_string(plint) ; str = PLUTO_get_string(plint) ; ud->format = (int)PLUTO_string_index( str , NUM_FORMAT_STRINGS , format_strings ); continue; } } while (1); /* ------------------ Check for some errorsor inconsistencies ------------- */ if (ud->iloc == -1 && ud->xloc == -1) { return "**************************\n" "At least iloc or x/y/zloc\n" "must be specified\n" "**************************\n" ; } if (ud->iloc != -1 && ud->xloc != -1) { return "***************************\n" "iloc AND x/y/zloc can not\n" "be simultaneously specified\n" "***************************\n" ; } /* ------------------Done with user parameters ---------------------------- */ /* Now loadup that index list or the xyz list */ if (ud->iloc != -1) { itmp = 0; /* might want to give option of setting it to number of rows if*/ /* the users know it, otherwise, it is automatically determined*/ ud->indvect = extract_index (ud->strin, ud->iloc, ud->ncols, &itmp, &Err); } else /* assuming the only other case is that x y z are specified */ { itmp = 0; ud->xyzvect = extract_xyz (ud->strin , ud->xloc , ud->yloc , ud->zloc , ud->ncols, &itmp, &Err); } ud->nrows = itmp; switch (Err) { case (0): break; case (1): return "****************************************\n" "index location should be > 0 and < ncols\n" "****************************************\n"; case (2): return "********************************************\n" "file size and number of columns do not match\n" "********************************************\n"; case (3): return "**********************\n" "Can't find matrix file\n" "**********************\n"; case (4): return "*****************\n" "ncols must be > 0\n" "*****************\n"; case (5): return "****************************************\n" "x/y/z column numbers can NOT be the same\n" "****************************************\n"; default: return "****************************************\n" "Should not have gotten here .....\n" "****************************************\n"; } if (strcmp (ud->strout,"") == 0) /* no output file is specified */ { sprintf ( tmpstr , "%s" , ud->new_prefix); ud->strout = tmpstr; } if (filexists(ud->strout) == 1) { return "*******************************\n" "Outfile exists, won't overwrite\n" "*******************************\n"; } ud->outwritets = fopen (ud->strout ,"w"); sprintf ( tmpstr , "%s.log" , ud->strout); if (filexists(tmpstr) == 1) { return "*******************************\n" "Outfile.log exists, won't overwrite\n" "*******************************\n"; } ud->outlogfile = fopen (tmpstr ,"w"); if ((ud->outwritets == NULL) || (ud->outlogfile == NULL) ) { ud->errcode = ERROR_FILEWRITE; return "***********************\n" "Could Not Write Outfile\n" "***********************\n"; } ud->nxx = (int)old_dset->daxes->nxx; /* get data set dimensions */ ud->nyy = (int)old_dset->daxes->nyy; ud->nzz = (int)old_dset->daxes->nzz; /* ready to dump the log file */ write_ud (ud); /*------------- ready to compute new dataset -----------*/ new_dset = PLUTO_4D_to_typed_fim( old_dset , /* input dataset */ ud->new_prefix , /* output prefix */ -1, /* negative value indicating data type is like original brick */ ud->ignore , /* ignore count */ ud->dtrnd , /* detrend */ EXTRACT_tsfunc , /* timeseries processor */ (void *)ud /* data for tsfunc */ ) ; PLUTO_add_dset( plint , new_dset , DSET_ACTION_MAKE_CURRENT ) ; fclose (ud->outlogfile); fclose (ud->outwritets); free (tmpstr); free (nprfxstr); return NULL ; /* null string returned means all was OK */ }
THD_3dim_dataset * Volumewise_Operations(THD_3dim_dataset *dset, char *prefix, int datum) { int iv6[] = { 17, 0, 13, 4, 6, 8 }; float fv = 3.14159; THD_3dim_dataset *oset = NULL; int nvox, isb, ivx; float *sb=NULL, *vout=NULL, *yout=NULL; char *stmp; ENTRY("Volumewise_Operations"); DSET_load(dset); nvox = DSET_NVOX(dset); vout = (float *)calloc(nvox, sizeof(float)); /* Allocate for one whole volume, one sub-brick that is */ yout = (float *)calloc(nvox, sizeof(float)); /* and another */ for (isb=0; isb<DSET_NVALS(dset); ++isb) { if (!(sb = THD_extract_to_float(isb, dset))) { ERROR_message("Failed to extract sub-brick %d from %s\n", isb, DSET_PREFIX(dset)); RETURN(NULL); } for (ivx=0; ivx<nvox; ++ivx) { vout[ivx] += sb[ivx]; yout[ivx] += 1./(sqrt(fabs(sb[ivx])+0.1)); } free(sb); sb = NULL; } /* Put the results in a new dataset */ oset = EDIT_empty_copy( dset ) ; if (datum == MRI_float) { /* store results as float */ stmp = modify_afni_prefix(prefix,NULL,".volops.float"); EDIT_dset_items( oset , ADN_prefix , stmp, ADN_datum_all, MRI_float , ADN_nvals , 2 , ADN_ntt, 0, ADN_none ) ; EDIT_substitute_brick( oset , 0 , MRI_float , vout ) ; vout = NULL; /* do not free vout, oset uses the same pointer because column types is oset are float */ EDIT_substitute_brick( oset , 1 , MRI_float , yout ) ; yout = NULL; } else { /* store results as short */ stmp = modify_afni_prefix(prefix,NULL,".volops.short"); EDIT_dset_items( oset , ADN_prefix , stmp, ADN_datum_all, MRI_short , ADN_nvals , 2 , ADN_none ) ; /* Store the results using short precision and auto scale */ EDIT_substscale_brick(oset, 0, MRI_float, vout, MRI_short, -1.0); free(vout); vout = NULL; /* vout got copied by value, so free it */ /* Store the results using short precision and set your own scale (here out of laziness I used the same scale as for sub-brick 0) */ EDIT_substscale_brick(oset, 1, MRI_float, yout, MRI_short, DSET_BRICK_FACTOR(oset,0)); free(yout); yout = NULL; /* vout got copied by value, so free it */ } /* Label the sub-bricks */ EDIT_BRICK_LABEL(oset , 0, "sum"); EDIT_BRICK_LABEL(oset , 1, "sisqrt"); /* Add your own special attribute -- Note that private attributes are not preserved when making copies of datasets */ THD_set_string_atr( oset->dblk , "Pinot_Noir" , "sideways" ) ; THD_set_int_atr ( oset->dblk , "Lottery_Numbers", 6, iv6 ); THD_set_float_atr( oset->dblk , "PI", 1, &fv ); RETURN(oset); }
int main( int argc , char *argv[] ) { THD_3dim_dataset *dset ; char *prefix=NULL , *fname ; int narg=1 , flags=0 , ii , swap = 0; #ifndef DONT_ALLOW_MINC WARNING_message("This program (3dAFNItoMINC) is old, not maintained, and probably useless!") ; if( argc < 2 || strcmp(argv[1],"-help") == 0 ){ printf("Usage: 3dAFNItoMINC [options] dataset\n" "Reads in an AFNI dataset, and writes it out as a MINC file.\n" "\n" "OPTIONS:\n" " -prefix ppp = Write result into file ppp.mnc;\n" " default prefix is same as AFNI dataset's.\n" " -floatize = Write MINC file in float format.\n" " -swap = Swap bytes when passing data to rawtominc\n" "\n" "NOTES:\n" "* Multi-brick datasets are written as 4D (x,y,z,t) MINC\n" " files.\n" "* If the dataset has complex-valued sub-bricks, then this\n" " program won't write the MINC file.\n" "* If any of the sub-bricks have floating point scale\n" " factors attached, then the output will be in float\n" " format (regardless of the presence of -floatize).\n" "* This program uses the MNI program 'rawtominc' to create\n" " the MINC file; rawtominc must be in your path. If you\n" " don't have rawtominc, you must install the MINC tools\n" " software package from MNI. (But if you don't have the\n" " MINC tools already, why do you want to convert to MINC\n" " format anyway?)\n" "* At this time, you can find the MINC tools at\n" " ftp://ftp.bic.mni.mcgill.ca/pub/minc/\n" " You need the latest version of minc-*.tar.gz and also\n" " of netcdf-*.tar.gz.\n" "\n" "-- RWCox - April 2002\n" ) ; PRINT_COMPILE_DATE; exit(0) ; } mainENTRY("3dAFNItoMINC main"); machdep(); PRINT_VERSION("3dAFNItoMINC"); while( narg < argc && argv[narg][0] == '-' ){ if( strcmp(argv[narg],"-prefix") == 0 ){ prefix = argv[++narg] ; if( !THD_filename_ok(prefix) || prefix[0] == '-' ){ fprintf(stderr,"** Prefix string is illegal: %s\n",prefix) ; exit(1) ; } narg++ ; continue ; } if( strcmp(argv[narg],"-floatize") == 0 ){ flags |= MINC_FLOATIZE_MASK ; narg++ ; continue ; } if( strcmp(argv[narg],"-swap") == 0 ){ flags |= MINC_SWAPIZE_MASK ; narg++ ; continue ; } fprintf(stderr,"** ERROR: unknown option: %s\n",argv[narg]); exit(1); } if( narg >= argc ){ fprintf(stderr,"** ERROR: no dataset on command line?\n"); exit(1); } dset = THD_open_dataset(argv[narg]); CHECK_OPEN_ERROR(dset,argv[narg]) ; if( prefix == NULL ) prefix = DSET_PREFIX(dset) ; fname = malloc( strlen(prefix)+16 ) ; strcpy(fname,prefix) ; if( strstr(fname,".mnc") == NULL ) strcat(fname,".mnc") ; ii = THD_write_minc( fname , dset , flags ) ; exit(0) ; #else ERROR_exit("program 3dAFNItoMINC is no longer compiled") ; #endif }
int THD_conformist( int ndset, THD_3dim_dataset **dset, int flags , int *ijkpad ) { int iset , xpad_m,xpad_p , ypad_m,ypad_p , zpad_m,zpad_p , nwrit ; THD_dataxes *cx , *dx ; THD_3dim_dataset *qset ; int_pair pm ; int do_norefit = (flags & CONFORM_NOREFIT) ; int do_rewrite = (flags & CONFORM_REWRITE) && !do_norefit ; int do_ijkpad = (ijkpad != NULL) ; ENTRY("THD_conformist") ; /* check for good inputs */ if( ndset <= 0 || dset == NULL ) RETURN(-1) ; for( iset=0 ; iset < ndset ; iset++ ) if( !ISVALID_DSET(dset[iset]) ) RETURN(-2) ; /* check if all inputs are on the same grid (i.e., no work to do) */ for( iset=1 ; iset < ndset ; iset++ ){ if( ! EQUIV_DATAXES(dset[0]->daxes,dset[iset]->daxes) ) break ; } if( iset == ndset ){ if( do_ijkpad ){ for( iset=0 ; iset < 6*ndset ; iset++ ) ijkpad[iset] = 0 ; } RETURN(0) ; } /* construct the dataxes that encloses all the input datasets */ cx = THD_superset_dataxes( dset[0]->daxes , dset[1]->daxes ) ; if( cx == NULL ){ ERROR_message("3dConformist: '%s' and '%s' aren't compatible", DSET_HEADNAME(dset[0]) , DSET_HEADNAME(dset[1]) ) ; RETURN(-3) ; } for( iset=2 ; iset < ndset ; iset++ ){ dx = THD_superset_dataxes( cx , dset[iset]->daxes ) ; if( dx == NULL ){ ERROR_message("3dConformist: '%s' is not compatible with others", DSET_HEADNAME(dset[iset]) ) ; myXtFree(cx) ; RETURN(-3) ; } myXtFree(cx) ; cx = dx ; dx = NULL ; } /* now, re-create and re-write all datasets */ if( do_rewrite ) fprintf(stderr," + thd_conformist re-write loop: ") ; for( nwrit=iset=0 ; iset < ndset ; iset++ ){ if( EQUIV_DATAXES(cx,dset[iset]->daxes) ){ /* already OK */ if( do_rewrite ) fprintf(stderr,"-") ; if( do_ijkpad ) ijkpad[6*iset+0] = ijkpad[6*iset+1] = ijkpad[6*iset+2] = ijkpad[6*iset+3] = ijkpad[6*iset+4] = ijkpad[6*iset+5] = 0 ; continue ; } pm = zpadax_pm( cx->nxx , cx->xxorg , dset[iset]->daxes->nxx , dset[iset]->daxes->xxorg , cx->xxdel ) ; xpad_m = pm.i ; xpad_p = pm.j ; pm = zpadax_pm( cx->nyy , cx->yyorg , dset[iset]->daxes->nyy , dset[iset]->daxes->yyorg , cx->yydel ) ; ypad_m = pm.i ; ypad_p = pm.j ; pm = zpadax_pm( cx->nzz , cx->zzorg , dset[iset]->daxes->nzz , dset[iset]->daxes->zzorg , cx->zzdel ) ; zpad_m = pm.i ; zpad_p = pm.j ; if( do_ijkpad ){ ijkpad[6*iset+0] = xpad_m; ijkpad[6*iset+1] = xpad_p; ijkpad[6*iset+2] = ypad_m; ijkpad[6*iset+3] = ypad_p; ijkpad[6*iset+4] = zpad_m; ijkpad[6*iset+5] = zpad_p; } if( do_norefit ) continue ; /* just wanted ijkpad, I guess */ qset = THD_zeropad( dset[iset] , xpad_m,xpad_p , ypad_m,ypad_p , zpad_m,zpad_p , "BertieWooster" , ZPAD_PURGE | ZPAD_IJK ) ; if( qset == NULL ){ /* this should never happen */ if( do_rewrite ) fprintf(stderr,"\n") ; ERROR_message("thd_conformist: skipping dataset %s", DSET_HEADNAME(dset[iset])) ; continue ; } qset->idcode = dset[iset]->idcode ; EDIT_dset_items( qset , ADN_prefix , DSET_PREFIX(dset[iset]) , ADN_none ) ; if( do_rewrite ){ THD_delete_3dim_dataset( dset[iset] , True ) ; DSET_overwrite(qset) ; DSET_unload(qset) ; fprintf(stderr,"+") ; } else { THD_delete_3dim_dataset( dset[iset] , False ) ; } dset[iset] = qset ; nwrit++ ; } if( do_rewrite ) fprintf(stderr,"\n") ; RETURN(nwrit) ; }
int *THD_unique_rank( THD_3dim_dataset *mask_dset , int miv, byte *cmask, char *mapname, int **unqp, int *N_unq) { int nvox , ii, *unq = NULL, *vals=NULL, imax=0; INT_HASH_DATUM *rmap=NULL, *hd=NULL; int n_unique, r; FILE *fout=NULL; n_unique = 0; unq = NULL ; if (unqp && *unqp!=NULL) { fprintf(stderr,"** unqp (%p) not initialized properly to NULL", *unqp); return (vals) ; } if( !ISVALID_DSET(mask_dset) || miv < 0 || miv >= DSET_NVALS(mask_dset) ) { fprintf(stderr,"** Bad mask_dset or sub-brick index.\n"); return (vals) ; } nvox = DSET_NVOX(mask_dset) ; DSET_load(mask_dset) ; if( !DSET_LOADED(mask_dset) ) return (vals) ; if (!is_integral_sub_brick (mask_dset, miv, 0)) { fprintf(stderr,"** Sub-brick %d of %s is not integral valued.\n", miv, DSET_PREFIX(mask_dset) ? DSET_PREFIX(mask_dset):"NULL"); return (vals) ; } vals = (int *)malloc(sizeof(int)*nvox); if (!vals) { fprintf(stderr,"** Failed to allocate.\n"); return (vals) ; } switch( DSET_BRICK_TYPE(mask_dset,miv) ){ default: fprintf( stderr, "** Bad dset type for unique operation.\n" "Only Byte, Short and float dsets are allowed.\n"); DSET_unload(mask_dset) ; if (vals) free(vals); vals = NULL; return (vals) ; case MRI_short:{ short *mar = (short *) DSET_ARRAY(mask_dset,miv) ; if (cmask) { for( ii=0 ; ii < nvox ; ii++ ) if (cmask[ii]) vals[ii] = (int)(mar[ii]); else vals[ii] = 0; } else { for( ii=0 ; ii < nvox ; ii++ ) vals[ii] = (int)(mar[ii]); } } break ; case MRI_byte:{ byte *mar = (byte *) DSET_ARRAY(mask_dset,miv) ; if (cmask) { for( ii=0 ; ii < nvox ; ii++ ) if (cmask[ii]) vals[ii] = (int)(mar[ii]); else vals[ii] = 0; } else { for( ii=0 ; ii < nvox ; ii++ ) vals[ii] = (int)(mar[ii]); } } break ; case MRI_float:{ /* not an integral type but we store ints (from NIFTI) as floats */ float *mar = (float *) DSET_ARRAY(mask_dset,miv) ; if (cmask) { for( ii=0 ; ii < nvox ; ii++ ) if (cmask[ii]) vals[ii] = (int)(mar[ii]); else vals[ii] = 0; } else { for( ii=0 ; ii < nvox ; ii++ ) vals[ii] = (int)(mar[ii]); } } break ; } /* unique */ unq = UniqueInt (vals, nvox, &n_unique, 0 ); /* fprintf(stderr,"-- Have %d unique values\n", n_unique); */ if (!unq) { fprintf(stderr,"** Failed to create unique list\n"); free(vals); return (NULL); } if (mapname && mapname[0]) { /*fprintf(stderr,"-- Writing mapping to >>%s<<\n", mapname);*/ if ((fout = fopen(mapname,"w"))) { fprintf(fout, "#Rank Map (%d unique values)\n", n_unique); fprintf(fout, "#Col. 0: Rank\n"); fprintf(fout, "#Col. 1: Input Dset Value\n"); } } /* now replace by rank */ #if 0 for (r=0; r<n_unique; ++r) { /* fprintf(stderr,"-- Doing %d ...\n", unq[r]); */ if (cmask) { for (ii=0; ii<nvox; ii++) { if (cmask[ii]) { if (vals[ii] == unq[r]) vals[ii] = r; } else vals[ii] = 0; } } else { for( ii=0 ; ii < nvox ; ii++ ) if (vals[ii] == unq[r]) vals[ii] = r; } } #else /* faster approach */ imax=0; for (r=0; r<n_unique; ++r) { if (imax < unq[r]) imax = unq[r]; if (fout) fprintf(fout, "%d %d\n", r, unq[r]); hd = (INT_HASH_DATUM*)calloc(1,sizeof(INT_HASH_DATUM)); hd->id = unq[r]; hd->index = r; HASH_ADD_INT(rmap, id, hd); } for (ii=0; ii<nvox; ii++) if (!cmask || cmask[ii]) { HASH_FIND_INT(rmap,&(vals[ii]),hd); if (hd) vals[ii] = hd->index; else { fprintf(stderr, "** Failed to find key %d inhash table\n", vals[ii]); free(vals); while (rmap) { hd=rmap; HASH_DEL(rmap,hd); free(hd); } return (NULL); } } /* destroy hash */ while (rmap) { hd=rmap; HASH_DEL(rmap,hd); if (hd) free(hd); } #endif if (!unqp) free(unq); else *unqp = unq; unq = NULL; if (N_unq) *N_unq = n_unique; if (fout) fclose(fout); fout = NULL; return (vals) ; }
/*! Replace a voxel's value by the value's rank in the entire set of input datasets */ int main( int argc , char * argv[] ) { THD_3dim_dataset ** dsets_in = NULL, *dset=NULL; /*input and output datasets*/ int nopt=0, nbriks=0, nsubbriks=0, ib=0, isb=0; byte *cmask=NULL; int *all_uniques=NULL, **uniques=NULL, *final_unq=NULL, *N_uniques=NULL; int N_final_unq=0, iun=0, total_unq=0; INT_HASH_DATUM *rmap=NULL, *hd=NULL; int imax=0, iunq=0, ii=0, id = 0; long int off=0; char *prefix=NULL; char stmp[THD_MAX_PREFIX+1]={""}; FILE *fout=NULL; /*----- Read command line -----*/ if( argc < 2 || strcmp(argv[1],"-help") == 0 ){ Rank_help (); exit(0) ; } mainENTRY("3dRank main"); machdep(); AFNI_logger("3dRank",argc,argv); nopt = 1 ; while( nopt < argc && argv[nopt][0] == '-' ){ if( strcmp(argv[nopt],"-ver") == 0 ){ PRINT_VERSION("3dRank"); AUTHOR("Ziad Saad"); nopt++; continue; } if( strcmp(argv[nopt],"-help") == 0 ){ Rank_help(); exit(0) ; } if( strcmp(argv[nopt],"-prefix") == 0 ){ ++nopt; if (nopt>=argc) { fprintf(stderr,"**ERROR: Need string after -prefix\n"); exit(1); } prefix = argv[nopt] ; ++nopt; continue; } if( strcmp(argv[nopt],"-input") == 0 ){ dsets_in = (THD_3dim_dataset**) calloc(argc-nopt+1, sizeof(THD_3dim_dataset*)); ++nopt; nbriks=0; while (nopt < argc ) { dsets_in[nbriks] = THD_open_dataset( argv[nopt] ); if( !ISVALID_DSET(dsets_in[nbriks]) ){ fprintf(stderr,"**ERROR: can't open dataset %s\n",argv[nopt]) ; exit(1); } ++nopt; ++nbriks; } continue; } ERROR_exit( " Error - unknown option %s", argv[nopt]); } if (nopt < argc) { ERROR_exit( " Error unexplained trailing option: %s\n", argv[nopt]); } if (!nbriks) { ERROR_exit( " Error no volumes entered on command line?"); } /* some checks and inits*/ nsubbriks = 0; for (ib = 0; ib<nbriks; ++ib) { if (!is_integral_dset(dsets_in[ib], 0)) { ERROR_exit("Dset %s is not of an integral data type.", DSET_PREFIX(dsets_in[ib])); } nsubbriks += DSET_NVALS(dsets_in[ib]); } /* Now get unique arrays */ uniques = (int **)calloc(nsubbriks, sizeof(int*)); N_uniques = (int *)calloc(nsubbriks, sizeof(int)); total_unq = 0; iun = 0; for (ib = 0; ib<nbriks; ++ib) { DSET_mallocize(dsets_in[ib]); DSET_load(dsets_in[ib]); for (isb=0; isb<DSET_NVALS(dsets_in[ib]); ++isb) { uniques[iun] = THD_unique_vals(dsets_in[ib], isb, &(N_uniques[iun]), cmask); total_unq += N_uniques[iun]; ++iun; } } /* put all the arrays together and get the unique of the uniques */ all_uniques = (int *)calloc(total_unq, sizeof(int)); off=0; for (iun=0; iun<nsubbriks; ++iun) { memcpy(all_uniques+off, uniques[iun], N_uniques[iun]*sizeof(int)); off += N_uniques[iun]; } /* free intermediate unique arrays */ for (iun=0; iun<nsubbriks; ++iun) { free(uniques[iun]); } free(uniques); uniques=NULL; free(N_uniques); N_uniques=NULL; /* get unique of catenated array */ if (!(final_unq = UniqueInt (all_uniques, total_unq, &N_final_unq, 0 ))) { ERROR_exit( " Failed to get unique list (%d, %d, %d) ", total_unq, N_final_unq, nsubbriks); } free(all_uniques); all_uniques=NULL; if (prefix) { snprintf(stmp, sizeof(char)*THD_MAX_PREFIX, "%s.rankmap.1D", prefix); } else { if (nbriks == 1) { snprintf(stmp, sizeof(char)*THD_MAX_PREFIX, "%s.rankmap.1D", DSET_PREFIX(dsets_in[0])); } else { snprintf(stmp, sizeof(char)*THD_MAX_PREFIX, "%s+.rankmap.1D", DSET_PREFIX(dsets_in[0])); } } if (stmp[0]) { if ((fout = fopen(stmp,"w"))) { fprintf(fout, "#Rank Map (%d unique values)\n", N_final_unq); fprintf(fout, "#Col. 0: Rank\n"); fprintf(fout, "#Col. 1: Input Dset Value\n"); } } /* get the maximum integer in the unique array */ imax = 0; for (iunq=0; iunq<N_final_unq; ++iunq) { if (final_unq[iunq] > imax) imax = final_unq[iunq]; if (fout) fprintf(fout, "%d %d\n", iunq, final_unq[iunq]); hd = (INT_HASH_DATUM*)calloc(1,sizeof(INT_HASH_DATUM)); hd->id = final_unq[iunq]; hd->index = iunq; HASH_ADD_INT(rmap, id, hd); } fclose(fout); fout=NULL; /* now cycle over all dsets and replace their voxel values with rank */ for (ib = 0; ib<nbriks; ++ib) { for (isb=0; isb<DSET_NVALS(dsets_in[ib]); ++isb) { EDIT_BRICK_LABEL( dsets_in[ib],isb, "rank" ) ; EDIT_BRICK_TO_NOSTAT( dsets_in[ib],isb ) ; EDIT_BRICK_FACTOR( dsets_in[ib],isb, 0.0);/* no factors for rank*/ switch (DSET_BRICK_TYPE(dsets_in[ib],isb) ){ default: fprintf(stderr, "** Bad dset type for unique operation.\n" "Only Byte, Short, and float dsets are allowed.\n"); break ; /* this should not happen here, so don't bother returning*/ case MRI_short:{ short *mar = (short *) DSET_ARRAY(dsets_in[ib],isb) ; if (imax > MRI_TYPE_maxval[MRI_short]) { WARNING_message("Maximum rank value of %d is\n" "than maximum value for dset datatype of %d\n", imax, MRI_TYPE_maxval[MRI_short]); } for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ ) if (!cmask || cmask[ii]) { id = (int)mar[ii]; HASH_FIND_INT(rmap,&id ,hd); if (hd) mar[ii] = (short)(hd->index); else ERROR_exit("** Failed to find key %d in hash table\n",id); } else mar[ii] = 0; } break ; case MRI_byte:{ byte *mar ; if (imax > MRI_TYPE_maxval[MRI_short]) { WARNING_message("Maximum rank value of %d is\n" "than maximum value for dset datatype of %d\n", imax, MRI_TYPE_maxval[MRI_byte]); } mar = (byte *) DSET_ARRAY(dsets_in[ib],isb) ; for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ ) if (!cmask || cmask[ii]) { id = (int)mar[ii]; HASH_FIND_INT(rmap,&id ,hd); if (hd) mar[ii] = (byte)(hd->index); else ERROR_exit("** Failed to find key %d in hash table\n",id); } else mar[ii] = 0; } break ; case MRI_float:{ float *mar = (float *) DSET_ARRAY(dsets_in[ib],isb) ; for( ii=0 ; ii < DSET_NVOX(dsets_in[ib]) ; ii++ ) if (!cmask || cmask[ii]) { id = (int)mar[ii]; /* Assuming float is integral valued */ HASH_FIND_INT(rmap,&id ,hd); if (hd) mar[ii] = (float)(hd->index); else ERROR_exit("** Failed to find key %d in hash table\n",id); } else mar[ii] = 0; } break ; } } /* update range, etc. */ THD_load_statistics(dsets_in[ib]); /* Now write the bricks */ if (prefix) { if (nbriks == 1) { snprintf(stmp, sizeof(char)*THD_MAX_PREFIX, "%s", prefix); } else { snprintf(stmp, sizeof(char)*THD_MAX_PREFIX, "r%02d.%s", ib, prefix); } } else { snprintf(stmp, sizeof(char)*THD_MAX_PREFIX, "rank.%s", DSET_PREFIX(dsets_in[ib])); } EDIT_dset_items( dsets_in[ib] , ADN_prefix , stmp , ADN_none ) ; /* change storage mode, this way prefix will determine format of output dset */ dsets_in[ib]->dblk->diskptr->storage_mode = STORAGE_BY_BRICK; tross_Make_History( "3dRank" , argc, argv , dsets_in[ib] ) ; if (DSET_IS_MASTERED(dsets_in[ib])) { /* THD_write_3dim_dataset won't write a mastered dude */ dset = EDIT_full_copy(dsets_in[ib],stmp); } else { dset = dsets_in[ib]; } /* New ID */ ZERO_IDCODE(dset->idcode); dset->idcode = MCW_new_idcode() ; if (!THD_write_3dim_dataset( NULL, stmp, dset,True )) { ERROR_message("Failed to write %s", stmp); exit(1); } else { WROTE_DSET(dsets_in[ib]); if (dset != dsets_in[ib]) DSET_deletepp(dset); DSET_deletepp(dsets_in[ib]); } } /* destroy hash */ while (rmap) { hd = rmap; HASH_DEL(rmap,hd); free(hd); } free(final_unq); final_unq=NULL; exit(0); }
int main( int argc , char * argv[] ) { int ninp , ids , nv , iv,jv,kv , ivout , new_nvals , have_fdr = 0, nfdr = 0 ; THD_3dim_dataset * new_dset=NULL , * dset ; char buf[256] ; double angle; /*----- identify program -----*/ #if 0 printf ("\n\nProgram %s \n", PROGRAM_NAME); printf ("Last revision: %s \n\n", LAST_MOD_DATE); #endif /*** read input options ***/ mainENTRY("3dbucket main"); machdep(); PRINT_VERSION("3dbucket") ; set_obliquity_report(0); /* silence obliquity */ /*-- 20 Apr 2001: addto the arglist, if user wants to [RWCox] --*/ { int new_argc ; char ** new_argv ; addto_args( argc , argv , &new_argc , &new_argv ) ; if( new_argv != NULL ){ argc = new_argc ; argv = new_argv ; } } AFNI_logger("3dbucket",argc,argv) ; BUCK_read_opts( argc , argv ) ; /*** create new dataset (empty) ***/ ninp = BUCK_dsar->num ; if( ninp < 1 ){ fprintf(stderr,"*** No input datasets?\n") ; exit(1) ; } new_nvals = 0 ; for( ids=0 ; ids < ninp ; ids++ ) new_nvals += NSUBV(ids) ; if( BUCK_verb ) printf("-verb: output will have %d sub-bricks\n",new_nvals) ; new_dset = EDIT_empty_copy( DSUB(0) ) ; /* 23 May 2005: check for axis consistency */ /* 06 Feb 2008: and see if there are fdrcurves to perpetuate */ if( DSUB(0)->dblk->brick_fdrcurve ) have_fdr = 1 ; for( iv=1 ; iv < ninp ; iv++ ){ if( !EQUIV_DATAXES(new_dset->daxes,DSUB(iv)->daxes) ) fprintf(stderr,"++ WARNING: %s grid mismatch with %s\n", DSET_BRIKNAME(DSUB(0)) , DSET_BRIKNAME(DSUB(iv)) ) ; if( DSUB(iv)->dblk->brick_fdrcurve ) have_fdr = 1 ; angle = dset_obliquity_angle_diff(new_dset, DSUB(iv), -1.0); if (angle > 0.0) { WARNING_message( "dataset %s has an obliquity difference of %f degress with %s\n", new_dset , angle, DSUB(iv) ); } } /* if( ninp == 1 ) */ tross_Copy_History( DSUB(0) , new_dset ) ; tross_Make_History( "3dbucket" , argc,argv , new_dset ) ; EDIT_dset_items( new_dset , ADN_prefix , BUCK_output_prefix , ADN_directory_name, BUCK_session , ADN_type , BUCK_type , ADN_func_type , ISANATTYPE(BUCK_type) ? ANAT_BUCK_TYPE : FUNC_BUCK_TYPE, ADN_ntt , 0 , ADN_nvals , new_nvals , ADN_none ) ; /* can't re-write existing dataset, unless glueing is used */ if (! BUCK_glue){ if( THD_deathcon() && THD_is_file(DSET_HEADNAME(new_dset)) ){ fprintf(stderr,"*** Fatal error: file %s already exists!\n", DSET_HEADNAME(new_dset) ) ; exit(1) ; } } else { /* if glueing is used, make the 'new' dataset have the same idcode as the old one */ new_dset->idcode = DSUB(0) -> idcode ; /* copy the struct */ } THD_force_malloc_type( new_dset->dblk , DATABLOCK_MEM_MALLOC ) ; /* if there are fdr curves, allocate space 06 Feb 2008 [rickr] */ if( have_fdr ){ new_dset->dblk->brick_fdrcurve = (floatvec **)calloc(sizeof(floatvec *), new_nvals) ; if( !new_dset->dblk->brick_fdrcurve ){ fprintf(stderr,"** failed to alloc %d fdrcurves\n",new_nvals); exit(1); } if( BUCK_verb ) printf("-verb: adding fdrcurve list\n"); new_dset->dblk->brick_mdfcurve = (floatvec **)calloc(sizeof(floatvec *), /* 22 Oct 2008 */ new_nvals) ; } /*** loop over input datasets ***/ if( ninp > 1 ) myXtFree( new_dset->keywords ) ; ivout = 0 ; for( ids=0 ; ids < ninp ; ids++ ){ dset = DSUB(ids) ; nv = NSUBV(ids) ; if( ! BUCK_dry ){ DSET_load(dset) ; CHECK_LOAD_ERROR(dset) ; } /** loop over sub-bricks to output **/ for( iv=0 ; iv < nv ; iv++ ){ jv = SUBV(ids,iv) ; /* which sub-brick to use */ if( ! BUCK_dry ){ EDIT_substitute_brick( new_dset , ivout , DSET_BRICK_TYPE(dset,jv) , DSET_ARRAY(dset,jv) ) ; /*----- preserve label when one exists --- Modified March 2010 ZSS*/ if (DSET_HAS_LABEL(dset, jv) ) sprintf (buf, "%s", DSET_BRICK_LABEL(dset,jv)); else sprintf(buf,"%.12s[%d]",DSET_PREFIX(dset),jv) ; EDIT_dset_items( new_dset , ADN_brick_label_one+ivout, buf , ADN_none ) ; #if 0 sprintf(buf,"%s[%d]",DSET_FILECODE(dset),jv) ; EDIT_dset_items( new_dset, ADN_brick_keywords_replace_one+ivout, buf, ADN_none ) ; #endif EDIT_dset_items( new_dset , ADN_brick_fac_one +ivout, DSET_BRICK_FACTOR(dset,jv), #if 0 ADN_brick_keywords_append_one+ivout, DSET_BRICK_KEYWORDS(dset,jv) , #endif ADN_none ) ; /** possibly write statistical parameters for this sub-brick **/ kv = DSET_BRICK_STATCODE(dset,jv) ; if( FUNC_IS_STAT(kv) ){ /* input sub-brick has stat params */ int npar = FUNC_need_stat_aux[kv] , lv ; float * par = (float *) malloc( sizeof(float) * (npar+2) ) ; float * sax = DSET_BRICK_STATAUX(dset,jv) ; par[0] = kv ; par[1] = npar ; for( lv=0 ; lv < npar ; lv++ ) par[lv+2] = (sax != NULL) ? sax[lv] : 0.0 ; EDIT_dset_items(new_dset , ADN_brick_stataux_one+ivout , par , ADN_none ) ; free(par) ; /* 2: if the input dataset has statistical parameters */ } else if( ISFUNC(dset) && /* dset has stat */ FUNC_IS_STAT(dset->func_type) && /* params */ jv == FUNC_ival_thr[dset->func_type] ){ /* thr sub-brick */ int npar , lv ; float * par , * sax ; kv = dset->func_type ; npar = FUNC_need_stat_aux[kv] ; par = (float *) malloc( sizeof(float) * (npar+2) ) ; sax = dset->stat_aux ; par[0] = kv ; par[1] = npar ; for( lv=0 ; lv < npar ; lv++ ) par[lv+2] = (sax != NULL) ? sax[lv] : 0.0 ; EDIT_dset_items(new_dset , ADN_brick_stataux_one+ivout , par , ADN_none ) ; free(par) ; } /** append any fdrcurve **/ if( have_fdr ){ /* fixed iv->jv (ick!), noticed by dglen 16 Mar 2010 [rickr] */ if(dset->dblk->brick_fdrcurve && dset->dblk->brick_fdrcurve[jv]){ COPY_floatvec(new_dset->dblk->brick_fdrcurve[ivout], dset->dblk->brick_fdrcurve[jv]) ; nfdr++; } else new_dset->dblk->brick_fdrcurve[ivout] = NULL ; if(dset->dblk->brick_mdfcurve && dset->dblk->brick_mdfcurve[jv]){ COPY_floatvec(new_dset->dblk->brick_mdfcurve[ivout], dset->dblk->brick_mdfcurve[jv]) ; } else new_dset->dblk->brick_mdfcurve[ivout] = NULL ; } /** print a message? **/ if( BUCK_verb ) printf("-verb: copied %s[%d] into %s[%d]\n" , DSET_FILECODE(dset) , jv , DSET_FILECODE(new_dset) , ivout ) ; } else { printf("-dry: would copy %s[%d] into %s[%d]\n" , DSET_FILECODE(dset) , jv , DSET_FILECODE(new_dset) , ivout ) ; } ivout++ ; } /** loop over all bricks in input dataset and unload them if they aren't going into the output (not required, but is done to economize on memory) **/ if( ! BUCK_dry && nv < DSET_NVALS(dset) ){ for( kv=0 ; kv < DSET_NVALS(dset) ; kv++ ){ /* all input sub-bricks */ for( iv=0 ; iv < nv ; iv++ ){ /* all output sub-bricks */ jv = SUBV(ids,iv) ; if( jv == kv ) break ; /* input matches output */ } if( iv == nv ){ mri_free( DSET_BRICK(dset,kv) ) ; #if 0 if( BUCK_verb ) printf("-verb: unloaded unused %s[%d]\n" , DSET_FILECODE(dset) , kv ) ; #endif } } } } /* end of loop over input datasets */ if( ! BUCK_dry ){ if( BUCK_verb ){ if( have_fdr ) fprintf(stderr,"-verb: added %d of %d fdr curves\n", nfdr, new_nvals); fprintf(stderr,"-verb: loading statistics\n") ; } THD_load_statistics( new_dset ) ; if( BUCK_glue ) putenv("AFNI_DECONFLICT=OVERWRITE") ; if( BUCK_glue && BUCK_ccode >= 0 ) THD_set_write_compression(BUCK_ccode) ; /* 16 Mar 2010 */ THD_write_3dim_dataset( NULL,NULL , new_dset , True ) ; if( BUCK_verb ) fprintf(stderr,"-verb: wrote output: %s\n",DSET_BRIKNAME(new_dset)) ; } exit(0) ; }
THD_slist_find THD_dset_in_session( int find_type , void *target , THD_session *sess ) { int id , iv , im ; THD_3dim_dataset *dset ; THD_slist_find find ; /*-- sanity check --*/ ZZME(find) ; if( ! ISVALID_SESSION(sess) || target == NULL ){ BADFIND(find) ; return find ; } switch( find_type ){ /**** search for a name ****/ case FIND_NAME:{ char *target_name = (char *) target ; if( strlen(target_name) == 0 ){ BADFIND(find) ; return find ; } for( id=0 ; id < sess->num_dsset ; id++ ){ for( iv=FIRST_VIEW_TYPE ; iv <= LAST_VIEW_TYPE ; iv++ ){ dset = GET_SESSION_DSET(sess, id, iv); /* dset = sess->dsset_xform_table[id][iv] ;*/ if( dset != NULL && strcmp(dset->self_name,target_name) == 0 ){ find.dset = dset ; find.dset_index = id ; find.view_index = iv ; return find ; } } } } break ; /**** search for a prefix ****/ case FIND_PREFIX:{ char *target_prefix , *pp ; target_prefix = strdup((char *)target) ; pp = strstr(target_prefix,"+orig") ; /* 03 Jan 2012: */ if( pp == NULL ) pp = strstr(target_prefix,"+acpc") ; /* truncate +view */ if( pp == NULL ) pp = strstr(target_prefix,"+tlrc") ; /* if present */ if( pp == NULL ) pp = strstr(target_prefix,"[") ; if( pp != NULL ) *pp = '\0' ; if( *target_prefix == '\0' ){ free(target_prefix); BADFIND(find); return find; } for( id=0 ; id < sess->num_dsset ; id++ ){ for( iv=FIRST_VIEW_TYPE ; iv <= LAST_VIEW_TYPE ; iv++ ){ dset = GET_SESSION_DSET(sess, id, iv); /* dset = sess->dsset_xform_table[id][iv] ;*/ if( dset != NULL && strcmp(DSET_PREFIX(dset),target_prefix) == 0 ){ find.dset = dset ; find.dset_index = id ; find.view_index = iv ; free(target_prefix) ; return find ; } } } free(target_prefix) ; /* failed */ } break ; /**** search for an idcode ****/ case FIND_IDCODE:{ MCW_idcode target_id = *((MCW_idcode *) target) ; if( ISZERO_IDCODE(target_id) ){ BADFIND(find) ; return find ; } for( id=0 ; id < sess->num_dsset ; id++ ){ for( iv=FIRST_VIEW_TYPE ; iv <= LAST_VIEW_TYPE ; iv++ ){ dset = GET_SESSION_DSET(sess, id, iv); /* dset = sess->dsset_xform_table[id][iv] ;*/ if( dset != NULL && EQUIV_IDCODES(target_id,dset->idcode) ){ find.dset = dset ; find.dset_index = id ; find.view_index = iv ; return find ; } } } } break ; } /* end of switch on find_type */ /*-- fall thru --> not found --*/ BADFIND(find) ; return find ; }
int main( int argc , char * argv[] ) { int ninp , ids , nv , iv,jv,kv , ivout , new_nvals ; THD_3dim_dataset * new_dset=NULL , * dset ; char buf[256] ; /*----- Identify software -----*/ #if 0 printf ("\n\n"); printf ("Program: %s \n", PROGRAM_NAME); printf ("Author: %s \n", PROGRAM_AUTHOR); printf ("Initial Release: %s \n", PROGRAM_INITIAL); printf ("Latest Revision: %s \n", PROGRAM_LATEST); printf ("\n"); #endif /*** read input options ***/ if( argc < 2 || strncmp(argv[1],"-help",4) == 0 ) B2F_Syntax() ; mainENTRY("3dbuc2fim main"); machdep(); AFNI_logger(PROGRAM_NAME,argc,argv); PRINT_VERSION("3dbuc2fim") ; AUTHOR(PROGRAM_AUTHOR); B2F_read_opts( argc , argv ) ; /*** create new dataset (empty) ***/ ninp = B2F_dsar->num ; if( ninp < 1 ){ fprintf(stderr,"*** No input datasets?\n") ; exit(1) ; } new_nvals = 0 ; for( ids=0 ; ids < ninp ; ids++ ) new_nvals += NSUBV(ids) ; /*----- Check for acceptable number of sub-bricks -----*/ if (new_nvals < 1) { fprintf(stderr,"*** Less than 1 sub-brick specified\n") ; exit(1) ; } if (new_nvals > 2) { fprintf(stderr,"*** More than 2 sub-bricks specified\n") ; exit(1) ; } if( B2F_verb ) printf("-verb: output will have %d sub-bricks\n",new_nvals) ; new_dset = EDIT_empty_copy( DSUB(0) ) ; if( ninp == 1 ) tross_Copy_History( DSUB(0) , new_dset ) ; tross_Make_History( "3dbuc2fim" , argc,argv , new_dset ) ; /*----- Set default value for function type. This will be changed later, if the second sub-brick has a statistic type. -----*/ if (new_nvals == 1) B2F_func_type = FUNC_FIM_TYPE; else B2F_func_type = FUNC_THR_TYPE; EDIT_dset_items (new_dset , ADN_prefix , B2F_output_prefix , ADN_directory_name, B2F_session , ADN_type , HEAD_FUNC_TYPE, ADN_func_type , B2F_func_type, ADN_ntt , 0 , ADN_nvals , new_nvals , ADN_none ) ; if( THD_deathcon() && THD_is_file(DSET_HEADNAME(new_dset)) ){ fprintf(stderr,"*** Fatal error: file %s already exists!\n", DSET_HEADNAME(new_dset) ) ; exit(1) ; } THD_force_malloc_type( new_dset->dblk , DATABLOCK_MEM_MALLOC ) ; /*** loop over input datasets ***/ if( ninp > 1 ) myXtFree( new_dset->keywords ) ; ivout = 0 ; for( ids=0 ; ids < ninp ; ids++ ){ dset = DSUB(ids) ; nv = NSUBV(ids) ; DSET_load(dset) ; CHECK_LOAD_ERROR(dset) ; /** loop over sub-bricks to output **/ for( iv=0 ; iv < nv ; iv++ ){ jv = SUBV(ids,iv) ; /* which sub-brick to use */ EDIT_substitute_brick( new_dset , ivout , DSET_BRICK_TYPE(dset,jv) , DSET_ARRAY(dset,jv) ) ; /*----- If this sub-brick is from a bucket dataset, preserve the label for this sub-brick -----*/ if (dset->func_type == FUNC_BUCK_TYPE) sprintf (buf, "%s", DSET_BRICK_LABEL(dset,jv)); else sprintf(buf,"%.12s[%d]",DSET_PREFIX(dset),jv) ; EDIT_dset_items( new_dset , ADN_brick_label_one+ivout, buf , ADN_none ) ; #if 0 sprintf(buf,"%s[%d]",DSET_FILECODE(dset),jv) ; EDIT_dset_items( new_dset, ADN_brick_keywords_replace_one+ivout, buf, ADN_none ) ; #endif EDIT_dset_items( new_dset , ADN_brick_fac_one +ivout, DSET_BRICK_FACTOR(dset,jv), #if 0 ADN_brick_keywords_append_one+ivout, DSET_BRICK_KEYWORDS(dset,jv) , #endif ADN_none ) ; /** possibly write statistical parameters for this sub-brick **/ kv = DSET_BRICK_STATCODE(dset,jv) ; if( FUNC_IS_STAT(kv) ){ /* input sub-brick has stat params */ int npar = MAX_STAT_AUX , lv ; float * par = (float *) malloc( sizeof(float) * (npar) ) ; float * sax = DSET_BRICK_STATAUX(dset,jv) ; for( lv=0 ; lv < npar ; lv++ ) par[lv] = (sax != NULL && lv < FUNC_need_stat_aux[kv]) ? sax[lv] : 0.0; if (ivout == 1) { EDIT_dset_items(new_dset , ADN_func_type , kv, ADN_stat_aux, par , ADN_none ) ; } free(par) ; /* 2: if the input dataset has statistical parameters */ } else if( ISFUNC(dset) && /* dset has stat */ FUNC_IS_STAT(dset->func_type) && /* params */ jv == FUNC_ival_thr[dset->func_type] ){ /* thr sub-brick */ int npar , lv ; float * par , * sax ; kv = dset->func_type ; npar = MAX_STAT_AUX ; par = (float *) malloc( sizeof(float) * (npar+2) ) ; sax = dset->stat_aux ; for( lv=0 ; lv < npar ; lv++ ) par[lv] = (sax != NULL) ? sax[lv] : 0.0 ; if (ivout == 1) { for( lv=0 ; lv < npar+2 ; lv++ ) printf ("par[%d] = %f \n", lv, par[lv]); EDIT_dset_items(new_dset , ADN_func_type , kv, ADN_stat_aux, par , ADN_none ) ; } free(par) ; } /** print a message? **/ if( B2F_verb ) printf("-verb: copied %s[%d] into %s[%d]\n" , DSET_FILECODE(dset) , jv , DSET_FILECODE(new_dset) , ivout ) ; ivout++ ; } /** loop over all bricks in input dataset and unload them if they aren't going into the output (not required, but is done to economize on memory) **/ if( nv < DSET_NVALS(dset) ){ for( kv=0 ; kv < DSET_NVALS(dset) ; kv++ ){ /* all input sub-bricks */ for( iv=0 ; iv < nv ; iv++ ){ /* all output sub-bricks */ jv = SUBV(ids,iv) ; if( jv == kv ) break ; /* input matches output */ } if( iv == nv ){ mri_free( DSET_BRICK(dset,kv) ) ; #if 0 if( B2F_verb ) printf("-verb: unloaded unused %s[%d]\n" , DSET_FILECODE(dset) , kv ) ; #endif } } } } /* end of loop over input datasets */ if( B2F_verb ) fprintf(stderr,"-verb: loading statistics\n") ; THD_load_statistics( new_dset ) ; THD_write_3dim_dataset( NULL,NULL , new_dset , True ) ; if( B2F_verb ) fprintf(stderr,"-verb: wrote output: %s\n",DSET_BRIKNAME(new_dset)) ; exit(0) ; }