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) ;
}
int main(int argc, char *argv[]) {
int i,j,k,m,n,mm;
int iarg;
THD_3dim_dataset *insetTIME = NULL;
THD_3dim_dataset *MASK=NULL;
THD_3dim_dataset *ROIS=NULL;
char *prefix="NETCORR" ;
char in_name[300];
char in_mask[300];
char in_rois[300];
char OUT_grid[300];
char OUT_indiv[300];
char OUT_indiv0[300];
// int *SELROI=NULL; // if selecting subset of ROIs
// int HAVE_SELROI=0;
int NIFTI_OUT = 0;
byte ***mskd=NULL; // define mask of where time series are nonzero
byte *mskd2=NULL; // not great, but another format of mask
int HAVE_MASK=0;
int HAVE_ROIS=0;
int FISH_OUT=0;
int PART_CORR=0;
int TS_OUT=0;
int TS_LABEL=0;
int TS_INDIV=0;
int TS_WBCORR_r=0;
int TS_WBCORR_Z=0;
int *NROI_REF=NULL,*INVROI_REF=NULL;
int **ROI_LABELS_REF=NULL, **INV_LABELS_REF=NULL,**ROI_COUNT=NULL;
int ***ROI_LISTS=NULL;
double ***ROI_AVE_TS=NULL; // double because of GSL
float ***Corr_Matr=NULL;
float ***PCorr_Matr=NULL, ***PBCorr_Matr=NULL;
int Nvox=-1; // tot number vox
int *Dim=NULL;
int *Nlist=NULL;
Dtable *roi_dtable=NULL;
char *LabTabStr=NULL;
char ***ROI_STR_LABELS=NULL;
// for niml.dset -> graph viewing in SUMA
char ***gdset_roi_names=NULL;
SUMA_DSET *gset=NULL;
float ***flat_matr=NULL;
float *xyz=NULL;
char OUT_gdset[300];
NI_group *GDSET_netngrlink=NULL;
char *NAME_gdset=NULL;
int Noutmat = 1; // num of matr to output: start with CC for sure
char **ParLab=NULL;
int FM_ctr = 0; // for counting through flatmatr entries
int OLD_LABEL=0; // ooollld style format of regions: Nnumber:Rnumber
int IGNORE_LT=0; // ignore label table
int idx = 0;
int Nmask = 0;
FILE *fout1,*fin,*fout2;
AFNI_SETUP_OMP(0) ; /* 24 Jun 2013 */
mainENTRY("3dNetCorr"); machdep();
// ****************************************************************
// ****************************************************************
// load AFNI stuff
// ****************************************************************
// ****************************************************************
// INFO_message("version: BETA");
/** scan args **/
if (argc == 1) { usage_NetCorr(1); exit(0); }
iarg = 1;
while( iarg < argc && argv[iarg][0] == '-' ){
if( strcmp(argv[iarg],"-help") == 0 ||
strcmp(argv[iarg],"-h") == 0 ) {
usage_NetCorr(strlen(argv[iarg])>3 ? 2:1);
exit(0);
}
if( strcmp(argv[iarg],"-prefix") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-prefix'");
prefix = strdup(argv[iarg]) ;
if( !THD_filename_ok(prefix) )
ERROR_exit("Illegal name after '-prefix'");
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-inset") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-input'");
sprintf(in_name,"%s", argv[iarg]);
insetTIME = THD_open_dataset(in_name) ;
if( (insetTIME == NULL ))
ERROR_exit("Can't open time series dataset '%s'.",in_name);
// just 0th time point for output...
Dim = (int *)calloc(4,sizeof(int));
DSET_load(insetTIME); CHECK_LOAD_ERROR(insetTIME);
Nvox = DSET_NVOX(insetTIME) ;
Dim[0] = DSET_NX(insetTIME); Dim[1] = DSET_NY(insetTIME);
Dim[2] = DSET_NZ(insetTIME); Dim[3]= DSET_NVALS(insetTIME);
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-mask") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-mask'");
HAVE_MASK= 1;
sprintf(in_mask,"%s", argv[iarg]);
MASK = THD_open_dataset(in_mask) ;
if( (MASK == NULL ))
ERROR_exit("Can't open time series dataset '%s'.",in_mask);
DSET_load(MASK); CHECK_LOAD_ERROR(MASK);
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-in_rois") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-in_rois'");
sprintf(in_rois,"%s", argv[iarg]);
ROIS = THD_open_dataset(in_rois) ;
if( (ROIS == NULL ))
ERROR_exit("Can't open time series dataset '%s'.",in_rois);
DSET_load(ROIS); CHECK_LOAD_ERROR(ROIS);
HAVE_ROIS=DSET_NVALS(ROIS); //number of subbricks
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-fish_z") == 0) {
FISH_OUT=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-nifti") == 0) {
NIFTI_OUT=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-part_corr") == 0) {
PART_CORR=2; // because we calculate two matrices here
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-ts_out") == 0) {
TS_OUT=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-ts_label") == 0) {
TS_LABEL=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-ts_indiv") == 0) {
TS_INDIV=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-ts_wb_corr") == 0) {
TS_WBCORR_r=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-ts_wb_Z") == 0) {
TS_WBCORR_Z=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-old_labels") == 0) {
OLD_LABEL=1;
iarg++ ; continue ;
}
if( strcmp(argv[iarg],"-ignore_LT") == 0) {
IGNORE_LT=1;
iarg++ ; continue ;
}
/* if( strcmp(argv[iarg],"-sel_roi") == 0 ){
iarg++ ; if( iarg >= argc )
ERROR_exit("Need argument after '-in_rois'");
SELROI = (int *)calloc(MAX_SELROI,sizeof(int));
if( (fin = fopen(argv[iarg], "r")) == NULL) {
fprintf(stderr, "Error opening file %s.",argv[iarg]);
exit(1);
}
idx=0;
while( !feof(fin) && (idx<MAX_SELROI-1) ){
fscanf(fin, "%d",&SELROI[idx]);
fscanf(fin," ");
idx++;
}
HAVE_SELROI=idx;
printf("HAVE_SELROI=%d\n",HAVE_SELROI);
if(HAVE_SELROI<=0) {
ERROR_message("Error reading in `-sel_roi'-- appears to have no ROIs listed.\n");
exit(1);
}
iarg++ ; continue ;
}*/
ERROR_message("Bad option '%s'\n",argv[iarg]) ;
suggest_best_prog_option(argv[0], argv[iarg]);
exit(1);
}
INFO_message("Reading in.");
if( !TS_OUT && TS_LABEL) {
ERROR_message("with '-ts_label', you also need '-ts_out'.\n");
exit(1);
}
if (iarg < 3) {
ERROR_message("Too few options. Try -help for details.\n");
exit(1);
}
if(!HAVE_ROIS) {
ERROR_message("Need to load ROIs with >=1 subbrick...\n");
exit(1);
}
if(Nvox != DSET_NVOX(ROIS)) {
ERROR_message("Data sets of `-inset' and `in_rois' have "
"different numbers of voxels per brik!\n");
exit(1);
}
if( (HAVE_MASK>0) && (Nvox != DSET_NVOX(MASK)) ) {
ERROR_message("Data sets of `-inset' and `mask' have "
"different numbers of voxels per brik!\n");
exit(1);
}
// ****************************************************************
// ****************************************************************
// make storage
// ****************************************************************
// ****************************************************************
Nlist = (int *)calloc(1,sizeof(int));
mskd2 = (byte *)calloc(Nvox,sizeof(byte));
mskd = (byte ***) calloc( Dim[0], sizeof(byte **) );
for ( i = 0 ; i < Dim[0] ; i++ )
mskd[i] = (byte **) calloc( Dim[1], sizeof(byte *) );
for ( i = 0 ; i < Dim[0] ; i++ )
for ( j = 0 ; j < Dim[1] ; j++ )
mskd[i][j] = (byte *) calloc( Dim[2], sizeof(byte) );
if( (mskd == NULL) || (Nlist == NULL) || (mskd2 == NULL)) {
fprintf(stderr, "\n\n MemAlloc failure (masks).\n\n");
exit(122);
}
// *************************************************************
// *************************************************************
// Beginning of main loops
// *************************************************************
// *************************************************************
INFO_message("Allocating...");
// go through once: define data vox, and calc rank for each
for( k=0 ; k<Dim[2] ; k++ )
for( j=0 ; j<Dim[1] ; j++ )
for( i=0 ; i<Dim[0] ; i++ ) {
if( HAVE_MASK ) {
if( THD_get_voxel(MASK,idx,0)>0 ) {
mskd[i][j][k] = 1;
mskd2[idx] = 1;
Nmask++;
}
}
else // simple automask attempt
if( fabs(THD_get_voxel(insetTIME,idx,0))+
fabs(THD_get_voxel(insetTIME,idx,1))+
fabs(THD_get_voxel(insetTIME,idx,2))+
fabs(THD_get_voxel(insetTIME,idx,3))+
fabs(THD_get_voxel(insetTIME,idx,4)) > EPS_V) {
mskd[i][j][k] = 1;
mskd2[idx] = 1;
Nmask++;
}
idx+= 1; // skip, and mskd and KW are both still 0 from calloc
}
if (HAVE_MASK) {
DSET_delete(MASK);
free(MASK);
}
// obviously, this should always be TRUE at this point...
if(HAVE_ROIS>0) {
NROI_REF = (int *)calloc(HAVE_ROIS, sizeof(int));
INVROI_REF = (int *)calloc(HAVE_ROIS, sizeof(int));
if( (NROI_REF == NULL) || (INVROI_REF == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(122);
}
for( i=0 ; i<HAVE_ROIS ; i++)
INVROI_REF[i] = (int) THD_subbrick_max(ROIS, i, 1);
ROI_LABELS_REF = calloc( HAVE_ROIS,sizeof(ROI_LABELS_REF));
for(i=0 ; i<HAVE_ROIS ; i++)
ROI_LABELS_REF[i] = calloc(INVROI_REF[i]+1,sizeof(int));
INV_LABELS_REF = calloc( HAVE_ROIS,sizeof(INV_LABELS_REF));
for(i=0 ; i<HAVE_ROIS ; i++)
INV_LABELS_REF[i] = calloc(INVROI_REF[i]+1,sizeof(int));
if( (ROI_LABELS_REF == NULL) || (INV_LABELS_REF == NULL)
) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
INFO_message("Labelling regions internally.");
// Step 3A-2: find out the labels in the ref, organize them
// both backwards and forwards.
i = ViveLeRoi(ROIS,
ROI_LABELS_REF, // ordered list of ROILABEL ints, [1..M];
// maxval is N.
INV_LABELS_REF, // ith values at the actual input locs;
// maxval is M.
NROI_REF, // M: # of ROIs per brik
INVROI_REF); // N: max ROI label per brik
if( i != 1)
ERROR_exit("Problem loading/assigning ROI labels");
ROI_STR_LABELS = (char ***) calloc( HAVE_ROIS, sizeof(char **) );
for ( i=0 ; i<HAVE_ROIS ; i++ )
ROI_STR_LABELS[i] = (char **) calloc( NROI_REF[i]+1, sizeof(char *) );
for ( i=0 ; i<HAVE_ROIS ; i++ )
for ( j=0 ; j<NROI_REF[i]+1 ; j++ )
ROI_STR_LABELS[i][j] = (char *) calloc( 100 , sizeof(char) );
if( (ROI_STR_LABELS == NULL)) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
// Sept 2014: Labeltable stuff
if( IGNORE_LT ) {
INFO_message("Ignoring any '-in_rois' label table (if there is one).");
}
else{
if ((ROIS->Label_Dtable = DSET_Label_Dtable(ROIS))) {
if ((LabTabStr = Dtable_to_nimlstring( DSET_Label_Dtable(ROIS),
"VALUE_LABEL_DTABLE"))) {
//fprintf(stdout,"%s", LabTabStr);
if (!(roi_dtable = Dtable_from_nimlstring(LabTabStr))) {
ERROR_exit("Could not parse labeltable.");
}
}
else {
INFO_message("No label table from '-in_rois'.");
}
}
}
i = Make_ROI_Output_Labels( ROI_STR_LABELS,
ROI_LABELS_REF,
HAVE_ROIS,
NROI_REF,
roi_dtable,
1 );//!!!opts.DUMP_with_LABELS
ROI_COUNT = calloc( HAVE_ROIS,sizeof(ROI_COUNT));
for(i=0 ; i<HAVE_ROIS ; i++)
ROI_COUNT[i] = calloc(NROI_REF[i],sizeof(int));
if( (ROI_COUNT == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
// find num of vox per ROI
for( m=0 ; m<HAVE_ROIS ; m++ ) {
idx=0;
for( k=0 ; k<Dim[2] ; k++ )
for( j=0 ; j<Dim[1] ; j++ )
for( i=0 ; i<Dim[0] ; i++ ) {
if( (THD_get_voxel(ROIS,idx,m) > 0 ) && mskd[i][j][k] ) {
ROI_COUNT[m][INV_LABELS_REF[m][(int)
THD_get_voxel(ROIS,idx,m)]-1]++;
}
idx++;
}
}
// make list of vox per ROI
ROI_LISTS = (int ***) calloc( HAVE_ROIS, sizeof(int **) );
for ( i=0 ; i<HAVE_ROIS ; i++ )
ROI_LISTS[i] = (int **) calloc( NROI_REF[i], sizeof(int *) );
for ( i=0 ; i <HAVE_ROIS ; i++ )
for ( j=0 ; j<NROI_REF[i] ; j++ )
ROI_LISTS[i][j] = (int *) calloc( ROI_COUNT[i][j], sizeof(int) );
// make average time series per voxel
ROI_AVE_TS = (double ***) calloc( HAVE_ROIS, sizeof(double **) );
for ( i=0 ; i<HAVE_ROIS ; i++ )
ROI_AVE_TS[i] = (double **) calloc( NROI_REF[i], sizeof(double *) );
for ( i=0 ; i <HAVE_ROIS ; i++ )
for ( j=0 ; j<NROI_REF[i] ; j++ )
ROI_AVE_TS[i][j] = (double *) calloc( Dim[3], sizeof(double) );
// store corr coefs
Corr_Matr = (float ***) calloc( HAVE_ROIS, sizeof(float **) );
for ( i=0 ; i<HAVE_ROIS ; i++ )
Corr_Matr[i] = (float **) calloc( NROI_REF[i], sizeof(float *) );
for ( i=0 ; i <HAVE_ROIS ; i++ )
for ( j=0 ; j<NROI_REF[i] ; j++ )
Corr_Matr[i][j] = (float *) calloc( NROI_REF[i], sizeof(float) );
if( (ROI_LISTS == NULL) || (ROI_AVE_TS == NULL)
|| (Corr_Matr == NULL)) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
if(PART_CORR) {
PCorr_Matr = (float ***) calloc( HAVE_ROIS, sizeof(float **) );
for ( i=0 ; i<HAVE_ROIS ; i++ )
PCorr_Matr[i] = (float **) calloc( NROI_REF[i], sizeof(float *) );
for ( i=0 ; i <HAVE_ROIS ; i++ )
for ( j=0 ; j<NROI_REF[i] ; j++ )
PCorr_Matr[i][j] = (float *) calloc( NROI_REF[i], sizeof(float));
PBCorr_Matr = (float ***) calloc( HAVE_ROIS, sizeof(float **) );
for ( i=0 ; i<HAVE_ROIS ; i++ )
PBCorr_Matr[i] = (float **) calloc( NROI_REF[i], sizeof(float *) );
for ( i=0 ; i <HAVE_ROIS ; i++ )
for ( j=0 ; j<NROI_REF[i] ; j++ )
PBCorr_Matr[i][j] = (float *) calloc( NROI_REF[i], sizeof(float));
if( (PCorr_Matr == NULL) || (PBCorr_Matr == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(123);
}
}
// reuse this to help place list indices
for( i=0 ; i<HAVE_ROIS ; i++ )
for( j=0 ; j<NROI_REF[i] ; j++ )
ROI_COUNT[i][j] = 0;
INFO_message("Getting volumes.");
for( m=0 ; m<HAVE_ROIS ; m++ ) {
idx=0;
for( k=0 ; k<Dim[2] ; k++ )
for( j=0 ; j<Dim[1] ; j++ )
for( i=0 ; i<Dim[0] ; i++ ) {
if( (THD_get_voxel(ROIS,idx,m) > 0) && mskd[i][j][k] ) {
mm = INV_LABELS_REF[m][(int) THD_get_voxel(ROIS,idx,m)]-1;
ROI_LISTS[m][mm][ROI_COUNT[m][mm]] = idx;
ROI_COUNT[m][mm]++;
}
idx++;
}
}
}
// bit of freeing
for( i=0 ; i<Dim[0] ; i++)
for( j=0 ; j<Dim[1] ; j++) {
free(mskd[i][j]);
}
for( i=0 ; i<Dim[0] ; i++) {
free(mskd[i]);
}
free(mskd);
INFO_message("Calculating average time series.");
// ROI values
for(i=0 ; i<HAVE_ROIS ; i++)
for( j=0 ; j<NROI_REF[i] ; j++ ) {
Nlist[0]=ROI_COUNT[i][j];
k = CalcAveRTS(ROI_LISTS[i][j], ROI_AVE_TS[i][j],
insetTIME, Dim, Nlist);
}
INFO_message("Calculating correlation matrix.");
if(PART_CORR)
INFO_message("... and calculating partial correlation matrix.");
for(i=0 ; i<HAVE_ROIS ; i++) {
for( j=0 ; j<NROI_REF[i] ; j++ )
for( k=j ; k<NROI_REF[i] ; k++ ) {
Corr_Matr[i][j][k] = Corr_Matr[i][k][j] = (float)
CORR_FUN(ROI_AVE_TS[i][j], ROI_AVE_TS[i][k], Dim[3]);
}
if(PART_CORR)
mm = CalcPartCorrMatr(PCorr_Matr[i], PBCorr_Matr[i],
Corr_Matr[i], NROI_REF[i]);
}
// **************************************************************
// **************************************************************
// Store and output
// **************************************************************
// **************************************************************
INFO_message("Writing output: %s ...", prefix);
// - - - - - - - - NIML prep - - - - - - - - - - - - - -
if(FISH_OUT)
Noutmat++;
if(PART_CORR)
Noutmat+=2;
ParLab = (char **)calloc(Noutmat, sizeof(char *));
for (j=0; j<Noutmat; ++j)
ParLab[j] = (char *)calloc(32, sizeof(char));
if( (ParLab == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(121);
}
// NIML output
flat_matr = (float ***) calloc( HAVE_ROIS, sizeof(float **) );
for ( i = 0 ; i < HAVE_ROIS ; i++ )
flat_matr[i] = (float **) calloc( Noutmat, sizeof(float *) );
for ( i = 0 ; i < HAVE_ROIS ; i++ )
for ( j = 0 ; j < Noutmat ; j++ )
flat_matr[i][j] = (float *) calloc( NROI_REF[i]*NROI_REF[i],
sizeof(float));
gdset_roi_names = (char ***)calloc(HAVE_ROIS, sizeof(char **));
for (i=0; i< HAVE_ROIS ; i++ ) {
gdset_roi_names[i] = (char **)calloc(NROI_REF[i], sizeof(char *));
for (j=0; j<NROI_REF[i]; ++j) {
gdset_roi_names[i][j] = (char *)calloc(32, sizeof(char));
if( OLD_LABEL )
snprintf(gdset_roi_names[i][j],31,"N%03d:R%d", i,
ROI_LABELS_REF[i][j]);
else{
snprintf(gdset_roi_names[i][j],31,"%s",
ROI_STR_LABELS[i][j+1]);
//fprintf(stderr," %s ",
// ROI_STR_LABELS[i][j+1]);
}
}
}
if( (flat_matr == NULL) || ( gdset_roi_names == NULL) ) {
fprintf(stderr, "\n\n MemAlloc failure.\n\n");
exit(14);
}
for( k=0 ; k<HAVE_ROIS ; k++) { // each netw gets own file
sprintf(OUT_grid,"%s_%03d.netcc",prefix,k); // zero counting now
if( (fout1 = fopen(OUT_grid, "w")) == NULL) {
fprintf(stderr, "Error opening file %s.",OUT_grid);
exit(19);
}
// same format as .grid files now
fprintf(fout1,"# %d # Number of network ROIs\n",NROI_REF[k]); // NROIs
fprintf(fout1,"# %d # Number of netcc matrices\n",
FISH_OUT+PART_CORR+1); // Num of params
// Sept 2014: label_table stuff
// don't need labeltable to make them, can do anyways
fprintf(fout1, "# WITH_ROI_LABELS\n");
for( i=1 ; i<NROI_REF[k] ; i++ )
fprintf(fout1," %10s \t",ROI_STR_LABELS[k][i]);
fprintf(fout1," %10s\n",ROI_STR_LABELS[k][i]);
// THIS IS FOR KNOWING WHICH MATR WE'RE AT
// it's always zero for CC; they match one-to-one with later vars
FM_ctr = 0;
ParLab[FM_ctr] = strdup("CC");
for( i=1 ; i<NROI_REF[k] ; i++ ) // labels of ROIs
fprintf(fout1," %10d \t",ROI_LABELS_REF[k][i]);// at =NROI, have '\n'
fprintf(fout1," %10d\n# %s\n",ROI_LABELS_REF[k][i],"CC");
for( i=0 ; i<NROI_REF[k] ; i++ ) {
for( j=0 ; j<NROI_REF[k]-1 ; j++ ) {// b/c we put '\n' after last one.
fprintf(fout1,"%12.4f\t",Corr_Matr[k][i][j]);
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] = Corr_Matr[k][i][j];
}
fprintf(fout1,"%12.4f\n",Corr_Matr[k][i][j]);
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] = Corr_Matr[k][i][j];
}
if(FISH_OUT) {
FM_ctr++;
ParLab[FM_ctr] = strdup("FZ");
fprintf(fout1,"# %s\n", "FZ");
for( i=0 ; i<NROI_REF[k] ; i++ ) {
for( j=0 ; j<NROI_REF[k]-1 ; j++ ) {// b/c we put '\n' after last
fprintf(fout1,"%12.4f\t",BOBatanhf(Corr_Matr[k][i][j]));
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] =
BOBatanhf(Corr_Matr[k][i][j]);
/* fprintf(fout1,"%12.4f\t",FisherZ(Corr_Matr[k][i][j]));
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] =
FisherZ(Corr_Matr[k][i][j]);*/
}
fprintf(fout1,"%12.4f\n",BOBatanhf(Corr_Matr[k][i][j]));
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] =
BOBatanhf(Corr_Matr[k][i][j]);
/*fprintf(fout1,"%12.4f\n",FisherZ(Corr_Matr[k][i][j]));
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] =
FisherZ(Corr_Matr[k][i][j]);*/
}
}
if(PART_CORR) {
FM_ctr++;
ParLab[FM_ctr] = strdup("PC");
fprintf(fout1,"# %s\n", "PC");
for( i=0 ; i<NROI_REF[k] ; i++ ) {
for( j=0 ; j<NROI_REF[k]-1 ; j++ ) {// b/c we put '\n' after last
fprintf(fout1,"%12.4f\t",PCorr_Matr[k][i][j]);
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] = PCorr_Matr[k][i][j];
}
fprintf(fout1,"%12.4f\n",PCorr_Matr[k][i][j]);
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] = PCorr_Matr[k][i][j];
}
FM_ctr++;
ParLab[FM_ctr] = strdup("PCB");
fprintf(fout1,"# %s\n", "PCB");
for( i=0 ; i<NROI_REF[k] ; i++ ) {
for( j=0 ; j<NROI_REF[k]-1 ; j++ ) {// b/c we put '\n' after last
fprintf(fout1,"%12.4f\t",PBCorr_Matr[k][i][j]);
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] = PBCorr_Matr[k][i][j];
}
fprintf(fout1,"%12.4f\n",PBCorr_Matr[k][i][j]);
flat_matr[k][FM_ctr][i*NROI_REF[k]+j] = PBCorr_Matr[k][i][j];
}
}
fclose(fout1);
// more nimling
gset = SUMA_FloatVec_to_GDSET(flat_matr[k], Noutmat,
NROI_REF[k]*NROI_REF[k],
"full", ParLab,
NULL, NULL, NULL);
if( xyz = THD_roi_cmass(ROIS, k, ROI_LABELS_REF[k]+1, NROI_REF[k]) ) {
if (!(SUMA_AddGDsetNodeListElement(gset, NULL,
xyz, NULL, NULL,
gdset_roi_names[k],
NULL, NULL,
NROI_REF[k]))) {
ERROR_message("Failed to add node list");
exit(1);
}
free(xyz);
}
else {
ERROR_message("Failed in THD_roi_cmass"); exit(1);
}
sprintf(OUT_gdset,"%s_%03d",prefix,k);
GDSET_netngrlink =
Network_link(SUMA_FnameGet( OUT_gdset, "f",NULL));
NI_add_to_group(gset->ngr, GDSET_netngrlink);
NAME_gdset = SUMA_WriteDset_ns( OUT_gdset,
gset, SUMA_ASCII_NIML, 1, 0);
if (!NAME_gdset && !SUMA_IS_DSET_STDXXX_FORMAT(SUMA_ASCII_NIML)) {
ERROR_message("Failed to write dataset."); exit(1);
} else {
if (NAME_gdset) SUMA_free(NAME_gdset); NAME_gdset = NULL;
}
SUMA_FreeDset(gset);
gset=NULL;
}
if(TS_OUT) {
for( k=0 ; k<HAVE_ROIS ; k++) { // each netw gets own file
sprintf(OUT_grid,"%s_%03d.netts",prefix,k);
if( (fout1 = fopen(OUT_grid, "w")) == NULL) {
fprintf(stderr, "Error opening file %s.",OUT_grid);
exit(19);
}
for( i=0 ; i<NROI_REF[k] ; i++ ) {
if(TS_LABEL)
fprintf(fout1,"%d\t",ROI_LABELS_REF[k][i+1]); // labels go 1...M
for( j=0 ; j<Dim[3]-1 ; j++ ) // b/c we put '\n' after last one.
fprintf(fout1,"%.3e\t",ROI_AVE_TS[k][i][j]);
fprintf(fout1,"%.3e\n",ROI_AVE_TS[k][i][j]);
}
fclose(fout1);
}
}
if( TS_INDIV ) {
for( k=0 ; k<HAVE_ROIS ; k++) { // each netw gets own file
sprintf(OUT_indiv0,"%s_%03d_INDIV", prefix, k);
mkdir(OUT_indiv0, 0777);
for( i=0 ; i<NROI_REF[k] ; i++ ) {
sprintf(OUT_indiv,"%s/ROI_%03d.netts",
OUT_indiv0,ROI_LABELS_REF[k][i+1]);
if( (fout2 = fopen(OUT_indiv, "w")) == NULL) {
fprintf(stderr, "\nError opening file '%s'.\n",OUT_indiv);
exit(19);
}
for( j=0 ; j<Dim[3]-1 ; j++ ) // b/c we put '\n' after last one.
fprintf(fout2,"%.3e\t",ROI_AVE_TS[k][i][j]);
fprintf(fout2,"%.3e\n",ROI_AVE_TS[k][i][j]);
fclose(fout2);
}
}
}
if( TS_WBCORR_r || TS_WBCORR_Z ) {
INFO_message("Starting whole brain correlations.");
i = WB_netw_corr( TS_WBCORR_r,
TS_WBCORR_Z,
HAVE_ROIS,
prefix,
NIFTI_OUT,
NROI_REF,
Dim,
ROI_AVE_TS,
ROI_LABELS_REF,
insetTIME,
mskd2,
Nmask,
argc,
argv);
}
// ************************************************************
// ************************************************************
// Freeing
// ************************************************************
// ************************************************************
DSET_delete(ROIS);
free(ROIS);
for ( i = 0 ; i < HAVE_ROIS ; i++ ) {
for (j = 0; j < NROI_REF[i]; ++j)
free(gdset_roi_names[i][j]);
free(gdset_roi_names[i]);
}
free(gdset_roi_names);
for ( i = 0 ; i < HAVE_ROIS ; i++ )
for ( j = 0 ; j < Noutmat ; j++ )
free(flat_matr[i][j]);
for ( i = 0 ; i < HAVE_ROIS ; i++ )
free(flat_matr[i]);
free(flat_matr);
for( i=0 ; i<Noutmat ; i++)
free(ParLab[i]);
free(ParLab);
if(LabTabStr)
free(LabTabStr);
if(roi_dtable)
free(roi_dtable);
for ( i=0 ; i<HAVE_ROIS ; i++ )
for ( j=0 ; j<NROI_REF[i]+1 ; j++ )
free(ROI_STR_LABELS[i][j]);
for ( i=0 ; i<HAVE_ROIS ; i++ )
free(ROI_STR_LABELS[i]);
free(ROI_STR_LABELS);
DSET_delete(insetTIME);
free(insetTIME);
free(mskd2);
free(Nlist);
free(Dim); // need to free last because it's used for other arrays...
free(prefix);
// if(HAVE_SELROI)
// free(SELROI);
if(HAVE_ROIS >0) {
for( i=0 ; i<HAVE_ROIS ; i++) {
for( j=0 ; j<NROI_REF[i] ; j++) {
free(ROI_LISTS[i][j]);
free(ROI_AVE_TS[i][j]);
free(Corr_Matr[i][j]);
if(PART_CORR) {
free(PCorr_Matr[i][j]);
free(PBCorr_Matr[i][j]);
}
}
free(ROI_LISTS[i]);
free(ROI_AVE_TS[i]);
free(Corr_Matr[i]);
if(PART_CORR){
free(PCorr_Matr[i]);
free(PBCorr_Matr[i]);
}
free(ROI_LABELS_REF[i]);
free(INV_LABELS_REF[i]);
free(ROI_COUNT[i]);
}
free(ROI_LISTS);
free(ROI_AVE_TS);
free(Corr_Matr);
if(PART_CORR) {
free(PCorr_Matr);
free(PBCorr_Matr);
}
free(ROI_LABELS_REF);
free(INV_LABELS_REF);
free(ROI_COUNT);
free(NROI_REF);
free(INVROI_REF);
}
return 0;
}
