int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"SurfToSurf"}; SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt; SUMA_GENERIC_ARGV_PARSE *ps=NULL; SUMA_SurfaceObject *SO1=NULL, *SO2 = NULL; SUMA_SurfSpecFile *Spec = NULL; SUMA_M2M_STRUCT *M2M = NULL; int N_Spec=0, *nodeind = NULL, N_nodeind, icol, i, j; MRI_IMAGE *im = NULL, *im_data=NULL; int nvec=0, ncol=0, nvec_data=0, ncol_data=0, Nchar=0; float *far = NULL, *far_data=NULL, *dt = NULL, *projdir=NULL; char *outname = NULL, *s=NULL, sbuf[100]; void *SO_name = NULL; FILE *outptr=NULL; SUMA_Boolean exists = NOPE; SUMA_INDEXING_ORDER d_order = SUMA_NO_ORDER; SUMA_STRING *SS=NULL; SUMA_Boolean LocalHead = NOPE; SUMA_STANDALONE_INIT; SUMA_mainENTRY; /* Allocate space for DO structure */ SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS); ps = SUMA_Parse_IO_Args(argc, argv, "-i;-t;-spec;-s;-sv;-o;"); Opt = SUMA_SurfToSurf_ParseInput (argv, argc, ps); if (argc < 2) { SUMA_S_Err("Too few options"); usage_SurfToSurf(ps, 0); exit (1); } /* if output surface requested, check on pre-existing file */ if (ps->o_N_surfnames) { SO_name = SUMA_Prefix2SurfaceName(ps->o_surfnames[0], NULL, NULL, ps->o_FT[0], &exists); if (exists) { fprintf(SUMA_STDERR, "Error %s:\nOutput file(s) %s* on disk.\n" "Will not overwrite.\n", FuncName, ps->o_surfnames[0]); exit(1); } } if (Opt->debug > 2) LocalHead = YUP; outname = SUMA_append_extension(Opt->out_prefix,".1D"); if (SUMA_filexists(outname) && !THD_ok_overwrite()) { fprintf(SUMA_STDERR,"Output file %s exists.\n", outname); exit(1); } /* Load the surfaces from command line*/ Spec = SUMA_IO_args_2_spec(ps, &N_Spec); if (N_Spec != 1) { SUMA_S_Err( "Multiple spec at input.\n" "Do not mix surface input types together\n"); exit(1); } if (Spec->N_Surfs != 2) { SUMA_S_Err("2 surfaces expected."); exit(1); } SO1 = SUMA_Load_Spec_Surf(Spec, 0, ps->sv[0], 0); if (!SO1) { fprintf (SUMA_STDERR,"Error %s:\n" "Failed to find surface\n" "in spec file. \n", FuncName ); exit(1); } if (!SUMA_SurfaceMetrics(SO1, "EdgeList|MemberFace", NULL)) { SUMA_SL_Err("Failed to create edge list for SO1"); exit(1); } if (Opt->fix_winding) { int orient, trouble; if (LocalHead) fprintf(SUMA_STDERR, "%s: Making sure S1 is consistently orientated\n", FuncName); if (!SUMA_MakeConsistent (SO1->FaceSetList, SO1->N_FaceSet, SO1->EL, Opt->debug, &trouble)) { SUMA_SL_Err("Failed in SUMA_MakeConsistent"); } if (trouble && LocalHead) { fprintf(SUMA_STDERR, "%s: trouble value of %d from SUMA_MakeConsistent.\n" "Inconsistencies were found and corrected unless \n" "stderr output messages from SUMA_MakeConsistent\n" "indicate otherwise.\n", FuncName, trouble); } if (LocalHead) fprintf(SUMA_STDERR,"%s: Checking orientation.\n", FuncName); orient = SUMA_OrientTriangles (SO1->NodeList, SO1->N_Node, SO1->FaceSetList, SO1->N_FaceSet, 1, 0, NULL, NULL); if (orient < 0) { /* flipping was done, dump the edge list since it is not automatically updated (should do that in function, just like in SUMA_MakeConsistent, shame on you) If you revisit this section, use the newer: SUMA_OrientSOTriangles */ if (SO1->EL) SUMA_free_Edge_List(SO1->EL); SO1->EL = NULL; if (!SUMA_SurfaceMetrics(SO1, "EdgeList", NULL)) { SUMA_SL_Err("Failed to create edge list for SO1"); exit(1); } /* free normals, new ones needed (Normals should be flipped inside of SUMA_OrientTriangles! (just like in SUMA_MakeConsistent) ) */ if (SO1->NodeNormList) SUMA_free(SO1->NodeNormList); SO1->NodeNormList = NULL; if (SO1->FaceNormList) SUMA_free(SO1->FaceNormList); SO1->FaceNormList = NULL; } if (!orient) { fprintf(SUMA_STDERR, "Error %s:\nFailed in SUMA_OrientTriangles\n", FuncName); } if (LocalHead) { if (orient < 0) { SUMA_SL_Note("S1 was reoriented"); } else { SUMA_SL_Note("S1 was properly oriented"); } } } if (!SO1->NodeNormList || !SO1->FaceNormList) { SUMA_LH("Node Normals"); SUMA_RECOMPUTE_NORMALS(SO1); } if (Opt->NodeDbg >= SO1->N_Node) { SUMA_SL_Warn( "node_debug index is larger than number " "of nodes in surface, ignoring -node_debug."); Opt->NodeDbg = -1; } SO2 = SUMA_Load_Spec_Surf(Spec, 1, ps->sv[1], 0); if (!SO2) { fprintf (SUMA_STDERR,"Error %s:\n" "Failed to find surface\n" "in spec file. \n", FuncName ); exit(1); } if (!SUMA_SurfaceMetrics(SO2, "EdgeList|MemberFace", NULL)) { SUMA_SL_Err("Failed to create edge list for SO2"); exit(1); } if (!SO2->NodeNormList || !SO2->FaceNormList) { SUMA_LH("Node Normals"); SUMA_RECOMPUTE_NORMALS(SO2); } if (LocalHead) { SUMA_LH("Surf1"); SUMA_Print_Surface_Object(SO1, NULL); SUMA_LH("Surf2"); SUMA_Print_Surface_Object(SO2, NULL); } /* a select list of nodes? */ nodeind = NULL; N_nodeind = 0; if (Opt->in_nodeindices) { im = mri_read_1D(Opt->in_nodeindices); if (!im) { SUMA_SL_Err("Failed to read 1D file of node indices"); exit(1);} far = MRI_FLOAT_PTR(im); N_nodeind = nvec = im->nx; ncol = im->ny; if (ncol != 1) { SUMA_SL_Err("More than one column in node index input file."); exit(1); } nodeind = (int *)SUMA_calloc(nvec, sizeof(int)); if (!nodeind) { SUMA_SL_Crit("Failed to allocate"); exit(1); } for (i=0;i<nvec;++i) { nodeind[i] = (int)far[i]; if (nodeind[i] < 0 || nodeind[i] >= SO1->N_Node) { fprintf(SUMA_STDERR, "Error %s:\n" "A node index of %d was found in input file %s, entry %d.\n" "Acceptable indices are positive and less than %d\n", FuncName, nodeind[i], Opt->in_nodeindices, i, SO1->N_Node); exit(1); } } mri_free(im); im = NULL; /* done with that baby */ } /* a preset directions vector ?*/ projdir = NULL; if (Opt->in_1D) { im = mri_read_1D(Opt->in_1D); if (!im) { SUMA_SL_Err("Failed to read 1D file of projection directions"); exit(1); } far = MRI_FLOAT_PTR(im); if (im->ny != 3) { SUMA_SL_Err("Need three columns in projection directions file."); exit(1); } if (im->nx != SO1->N_Node) { fprintf(SUMA_STDERR, "Error %s: You must have a direction for each node in SO1.\n" "%d directions found but SO1 has %d nodes.\n", FuncName, im->nx, SO1->N_Node); exit(1); } /* change to row major major and make it match nodeind */ projdir = (float *)SUMA_calloc(SO1->N_Node*3, sizeof(float)); if (!projdir) { SUMA_SL_Crit("Failed to allocate"); exit(1); } for (i=0; i<SO1->N_Node; ++i) { projdir[3*i ] = far[i ]; projdir[3*i+1] = far[i+ SO1->N_Node]; projdir[3*i+2] = far[i+2*SO1->N_Node]; } mri_free(im); im = NULL; /* done with that baby */ } if (SO_name) { /* user is interpolating surface coords, check on other input insanity */ if (nodeind) { fprintf( SUMA_STDERR, "Error %s: You cannot combine " "option -o_TYPE with -node_indices", FuncName); exit(1); } if (Opt->in_name) { fprintf(SUMA_STDERR, "Error %s: You cannot combine option -o_TYPE with -data", FuncName); exit(1); } } /* a 1D file containing data, or Data parameter (for XYZ)? */ if (Opt->Data > 0) { if (Opt->in_name) { /* When you are ready to work with dsets, you should checkout the function morphDsetToStd. It uses M2M */ im_data = mri_read_1D(Opt->in_name); if (!im_data) { SUMA_SL_Err("Failed to read 1D file of data"); exit(1);} far_data = MRI_FLOAT_PTR(im_data); nvec_data = im_data->nx; ncol_data = im_data->ny; if (nvec_data != SO2->N_Node) { SUMA_SL_Err("Your data file must have one row " "for each node in surface 2.\n"); exit(1); } d_order = SUMA_COLUMN_MAJOR; } else { im_data = NULL; far_data = SO2->NodeList; nvec_data = SO2->N_Node; ncol_data = 3; d_order = SUMA_ROW_MAJOR; } } else { /* just -dset */ } if (!Opt->s) { SUMA_LH("Going for the mapping of SO1 --> SO2"); M2M = SUMA_GetM2M_NN( SO1, SO2, nodeind, N_nodeind, projdir, 0, Opt->NodeDbg, Opt->iopt); SUMA_S_Notev("Saving M2M into %s\n\n", Opt->out_prefix); if (!(SUMA_Save_M2M(Opt->out_prefix, M2M))) { SUMA_S_Err("Failed to save M2M"); exit(1); } } else { SUMA_S_Notev("Reusing mapping of SO1 --> SO2 from %s\n\n", Opt->s); if (!(M2M = SUMA_Load_M2M(Opt->s))) { SUMA_S_Errv("Failed to load %s\n", Opt->s); exit(1); } } /* Now show the mapping results for a debug node ? */ if (Opt->NodeDbg >= 0) { char *s = NULL; s = SUMA_M2M_node_Info(M2M, Opt->NodeDbg); fprintf(SUMA_STDERR,"%s: Debug for node %d ([%f, %f, %f])of SO1:\n%s\n\n", FuncName, Opt->NodeDbg, SO1->NodeList[3*Opt->NodeDbg], SO1->NodeList[3*Opt->NodeDbg+1], SO1->NodeList[3*Opt->NodeDbg+2], s); SUMA_free(s); s = NULL; } /* Now please do the interpolation */ if (Opt->Data > 0) { if (Opt->NearestNode > 1) dt = SUMA_M2M_interpolate( M2M, far_data, ncol_data, nvec_data, d_order, 0 ); else if (Opt->NearestNode == 1) dt = SUMA_M2M_interpolate( M2M, far_data, ncol_data, nvec_data, d_order, 1 ); if (!dt) { SUMA_SL_Err("Failed to interpolate"); exit(1); } } else if (Opt->Data < 0) { SUMA_DSET *dset=NULL, *dseto=NULL; char *oname=NULL, *uname=NULL, *s1=NULL, *s2=NULL; int iform=SUMA_NO_DSET_FORMAT; if (Opt->NodeDbg>= 0) { SUMA_S_Notev("Processing dset %s\n", Opt->in_name); } iform = SUMA_NO_DSET_FORMAT; if (!(dset = SUMA_LoadDset_s (Opt->in_name, &iform, 0))) { SUMA_S_Errv("Failed to load %s\n", Opt->in_name); exit(1); } if (!(dseto = SUMA_morphDsetToStd ( dset, M2M, Opt->NearestNode == 1 ? 1:0))) { SUMA_S_Errv("Failed to map %s\n", Opt->in_name); exit(1); } s1 = SUMA_append_string( SUMA_FnameGet(Opt->in_name,"pa", SUMAg_CF->cwd), Opt->out_prefix); s2 = SUMA_RemoveDsetExtension_s( SUMA_FnameGet(Opt->in_name,"l",SUMAg_CF->cwd), SUMA_NO_DSET_FORMAT); uname = SUMA_append_extension(s1,s2); SUMA_free(s1); SUMA_free(s2); oname = SUMA_WriteDset_s (uname, dseto, Opt->oform, 1, 1); if (Opt->NodeDbg>= 0) SUMA_S_Notev("Wrote %s\n", oname); if (oname) SUMA_free(oname); oname=NULL; if (uname) SUMA_free(uname); oname=NULL; if (dseto) SUMA_FreeDset(dseto); dseto = NULL; if (dset) SUMA_FreeDset(dset); dset = NULL; } SUMA_LH("Forming the remaining output"); outptr = fopen(outname,"w"); if (!outptr) { SUMA_SL_Err("Failed to open file for output.\n"); exit(1); } /* first create the header of the output */ SS = SUMA_StringAppend(NULL, NULL); SS = SUMA_StringAppend_va(SS, "#Mapping from nodes on surf 1 (S1) to nodes on surf 2 (S2)\n" "# Surf 1 is labeled %s, idcode:%s\n" "# Surf 2 is labeled %s, idcode:%s\n", SO1->Label, SO1->idcode_str, SO2->Label, SO2->idcode_str); icol = 0; SS = SUMA_StringAppend_va(SS, "#Col. %d:\n" "# S1n (or nj): Index of node on S1\n" , icol); ++icol; if (Opt->NearestNode > 1) { SS = SUMA_StringAppend_va(SS, "#Col. %d..%d:\n" "# S2ne_S1n: Indices of %d nodes on S2 \n" "# that are closest neighbors of nj.\n" "# The first index is that of the node on S2 that is closest \n" "# to nj. If -1 then these values should be ignored because\n" "# in such cases, nj's projection failed.\n" , icol, icol+Opt->NearestNode-1, Opt->NearestNode); icol += Opt->NearestNode; SS = SUMA_StringAppend_va(SS, "#Col. %d..%d:\n" "# S2we_S1n: Weights assigned to nodes on surf 2 (S2) \n" "# that are closest neighbors of nj.\n" , icol, icol+Opt->NearestNode-1, Opt->NearestNode); icol += Opt->NearestNode; } else if (Opt->NearestNode == 1) { SS = SUMA_StringAppend_va(SS, "#Col. %d:\n" "# S2ne_S1n: Index of the node on S2 (label:%s idcode:%s)\n" "# that is the closest neighbor of nj.\n" "# If -1 then this value should be ignored because\n" "# nj's projection failed.\n" , icol, SO2->Label, SO2->idcode_str); ++icol; } if (Opt->NearestTriangle) { SS = SUMA_StringAppend_va(SS, "#Col. %d:\n" "# S2t_S1n: Index of the S2 triangle that hosts node nj on S1.\n" "# In other words, nj's closest projection onto S2 falls on \n" "# triangle S2t_S1n\n" "# If -1 then this value should be ignored because \n" "# nj's projection failed.\n" , icol); ++icol; } if (Opt->ProjectionOnMesh) { SS = SUMA_StringAppend_va(SS, "#Col. %d..%d:\n" "# S2p_S1n: Coordinates of projection of nj onto S2\n" , icol, icol+2); icol += 3; } if (Opt->DistanceToMesh) { SS = SUMA_StringAppend_va(SS, "#Col. %d:\n" "# Closest distance from nj to S2\n" , icol); ++icol; } if (Opt->NearestNodeCoords) { SS = SUMA_StringAppend_va(SS, "#Col. %d .. %d:\n" "# X Y Z coords of nearest node\n" , icol, icol+2); icol += 3; } if (Opt->Data > 0) { if (!Opt->in_name) { SS = SUMA_StringAppend_va(SS, "#Col. %d..%d:\n" "# Interpolation using XYZ coordinates of S2 nodes that neighbor nj\n" "# (same as coordinates of node's projection onto triangle in S2, \n" "# if using barycentric interpolation)\n" , icol, icol+2); icol += 3; } else { SS = SUMA_StringAppend_va(SS, "#Col. %d..%d:\n" "# Interpolation of data at nodes on S2 that neighbor nj\n" "# Data obtained from %s\n" , icol, icol+ncol_data-1, Opt->in_name); icol += ncol_data; } } s = SUMA_HistString("SurfToSurf", argc, argv, NULL); SS = SUMA_StringAppend_va(SS, "#History:\n" "#%s\n", s); SUMA_free(s); s = NULL; SUMA_SS2S(SS,s); fprintf(outptr,"%s\n",s); SUMA_free(s); s = NULL; /* put headers atop columns */ Nchar = 6; /* if you change this number you'll need to fix formats below */ for (i=0; i<icol; ++i) { sprintf(sbuf,"#%s", MV_format_fval2(i, Nchar -1)); fprintf(outptr,"%6s ", sbuf); } fprintf(outptr,"\n"); /* Now put in the values, make sure you parallel columns above! */ for (i=0; i<M2M->M1Nn; ++i) { fprintf(outptr,"%6s ", MV_format_fval2(M2M->M1n[i], Nchar)); if (Opt->NearestNode > 0) { for (j=0; j<Opt->NearestNode; ++j) { if (j < M2M->M2Nne_M1n[i]) fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2ne_M1n[i][j], Nchar)); else fprintf(outptr,"%6s ", "-1"); } /* Neighboring nodes */ } if (Opt->NearestNode > 1) { /* add the weights */ for (j=0; j<Opt->NearestNode; ++j) { if (j < M2M->M2Nne_M1n[i]) fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2we_M1n[i][j], Nchar)); else fprintf(outptr,"%6s ", "0.0"); } } if (Opt->NearestTriangle) { fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2t_M1n[i], Nchar)); } if (Opt->ProjectionOnMesh) { fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2p_M1n[3*i], Nchar)); fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2p_M1n[3*i+1], Nchar)); fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2p_M1n[3*i+2], Nchar)); } if (Opt->DistanceToMesh) { fprintf(outptr,"%6s ", MV_format_fval2(M2M->PD[i], Nchar)); } if (Opt->NearestNodeCoords) { float x=0.0,y=0.0,z=0.0; int n = M2M->M2ne_M1n[i][0]; if (n>0) { n = n * SO2->NodeDim; x = SO2->NodeList[n]; y = SO2->NodeList[n+1]; z = SO2->NodeList[n+2]; } fprintf(outptr,"%6s ", MV_format_fval2(x, Nchar)); fprintf(outptr,"%6s ", MV_format_fval2(y, Nchar)); fprintf(outptr,"%6s ", MV_format_fval2(z, Nchar)); } if (dt && Opt->Data > 0) { if (!Opt->in_name) { fprintf(outptr,"%6s ", MV_format_fval2(dt[3*i], Nchar)); fprintf(outptr,"%6s ", MV_format_fval2(dt[3*i+1], Nchar)); fprintf(outptr,"%6s ", MV_format_fval2(dt[3*i+2], Nchar)); } else { /* Column major business */ for (j=0; j<ncol_data; ++j) { fprintf(outptr,"%6s ", MV_format_fval2(dt[i+j*M2M->M1Nn], Nchar)); } } } fprintf(outptr,"\n"); } /* do they want an output surface ? */ if (SO_name) { float *tmpfv = NULL; SUMA_LH("Writing surface"); tmpfv = SO1->NodeList; SO1->NodeList = dt; if (!SUMA_Save_Surface_Object (SO_name, SO1, ps->o_FT[0], ps->o_FF[0], NULL)) { SUMA_S_Err("Failed to write surface object.\n"); exit (1); } SO1->NodeList = tmpfv; tmpfv = NULL; } if (N_Spec) { int k=0; for (k=0; k<N_Spec; ++k) { if (!SUMA_FreeSpecFields(&(Spec[k]))) { SUMA_S_Err("Failed to free spec fields"); } } SUMA_free(Spec); Spec = NULL; N_Spec = 0; } if (projdir) SUMA_free(projdir); projdir = NULL; if (SO_name) SUMA_free(SO_name); SO_name = NULL; if (outptr) fclose(outptr); outptr = NULL; if (dt) SUMA_free(dt); dt = NULL; if (s) SUMA_free(s); s = NULL; if (im_data) mri_free(im_data); im_data = NULL; /* done with the data */ if (nodeind) SUMA_free(nodeind); nodeind = NULL; if (M2M) M2M = SUMA_FreeM2M(M2M); if (SO1) SUMA_Free_Surface_Object(SO1); SO1 = NULL; if (SO2) SUMA_Free_Surface_Object(SO2); SO2 = NULL; if (Spec) SUMA_free(Spec); Spec = NULL; if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL; if (Opt) Opt = SUMA_Free_Generic_Prog_Options_Struct(Opt); if (!SUMA_Free_CommonFields(SUMAg_CF)) SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1); 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; }