/* A function to executes the proper macros for message generation. This one here is for suma programs */ void WorkErrLog_s(void) { static char FuncName[MAX_ERRLOG_FUNCNAME]={"WorkErrLog_s"}; SUMA_Boolean LocalHead = NOPE; DListElmt *del=NULL; SUMA_ERRLOG *el=NULL; char mmm[256]; del = SUMA_PopErrLog(NULL); while (del) { el = (SUMA_ERRLOG *)del->data; sprintf(FuncName, "%s", el->FuncName); if (!strcmp(el->macroname,"L_Err")) { SUMA_L_Err("%s", el->msg); } else if (!strcmp(el->macroname,"SL_Err")) { SUMA_SL_Err("%s", el->msg); } else if (!strcmp(el->macroname,"SLP_Err")) { SUMA_SLP_Err("%s", el->msg); } else if (!strcmp(el->macroname,"L_Warn")) { SUMA_L_Warn("%s", el->msg); } else if (!strcmp(el->macroname,"SL_Warn")) { SUMA_SL_Warn("%s", el->msg); } else if (!strcmp(el->macroname,"SLP_Warn")){SUMA_SLP_Warn("%s", el->msg); } else if (!strcmp(el->macroname,"L_Note")) { SUMA_L_Note("%s", el->msg); } else if (!strcmp(el->macroname,"SL_Note")) { SUMA_SL_Note("%s", el->msg); } else if (!strcmp(el->macroname,"SLP_Note")){SUMA_SLP_Note("%s", el->msg); } else if (!strcmp(el->macroname,"L_Crit")) { SUMA_L_Crit("%s", el->msg); } else if (!strcmp(el->macroname,"SL_Crit")) { SUMA_SL_Crit("%s", el->msg); } else if (!strcmp(el->macroname,"SLP_Crit")){SUMA_SLP_Crit("%s", el->msg); } else { snprintf(mmm, 255*sizeof(char), "Bad macroname %s", el->macroname); sprintf(FuncName, "%s", "WorkErrLog_ns"); SUMA_S_Err("%s",mmm); } del = SUMA_PopErrLog(del); } }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"3dBRAIN_VOYAGERtoAFNI"}; SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt; SUMA_GENERIC_ARGV_PARSE *ps=NULL; SUMA_OPEN_DX_STRUCT **dx = NULL; THD_3dim_dataset *dset=NULL; char *sto3d = 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, ""); if (argc < 2) { usage_3dBRAIN_VOYAGERtoAFNI(ps); exit (1); } Opt = SUMA_3dBRAIN_VOYAGERtoAFNI_ParseInput (argv, argc, ps); if (Opt->debug > 2) LocalHead = YUP; dset = EDIT_empty_copy( NULL ) ; tross_Make_History( "3dBRAIN_VOYAGERtoAFNI" , argc,argv , dset) ; if (!(sto3d = SUMA_BrainVoyager_Read_vmr(Opt->in_name, dset, 1, Opt->b2, Opt->b1, Opt->Icold, Opt->out_prefix))) { if (Opt->debug) SUMA_SL_Err("Failed in SUMA_BrainVoyager_Read_vmr"); exit(1); } SUMA_LHv("Old command would be %s\n", sto3d); if (dset) { SUMA_LH("Writing Dset"); DSET_write(dset) ; if (LocalHead) { fprintf(SUMA_STDERR,"%s: Can use the following command to create dset with to3d:\n%s\n", FuncName,sto3d); } } else { /* the olde way */ if (system(sto3d)) { fprintf(SUMA_STDERR, "Error %s: Failed while executing shell command:\n%s\n" "Check to3d's error messages, and disk writing permissions.\n", FuncName, sto3d); } } if (sto3d) SUMA_free(sto3d); sto3d = NULL; if (dset) { DSET_delete(dset); dset = 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[]) {/* 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); }
SUMA_GENERIC_PROG_OPTIONS_STRUCT *SUMA_SurfToSurf_ParseInput( char *argv[], int argc, SUMA_GENERIC_ARGV_PARSE *ps) { static char FuncName[]={"SUMA_BrainWrap_ParseInput"}; SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt=NULL; int kar; SUMA_Boolean brk, accepting_out; SUMA_Boolean LocalHead = NOPE; SUMA_ENTRY; Opt = SUMA_Alloc_Generic_Prog_Options_Struct(); kar = 1; brk = NOPE; Opt->in_1D = NULL; Opt->NodeDbg = -1; Opt->debug = 0; Opt->NearestNode = 0; Opt->NearestTriangle = 0; Opt->DistanceToMesh = 0; Opt->ProjectionOnMesh = 0; Opt->NearestNodeCoords = 0; Opt->Data = 0; Opt->in_name = NULL; Opt->out_prefix = NULL; Opt->fix_winding = 0; Opt->iopt = 0; Opt->oform = SUMA_NO_DSET_FORMAT; accepting_out = NOPE; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (!brk && accepting_out) { /* make sure you have not begun with new options */ if (*(argv[kar]) == '-') accepting_out = NOPE; } if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { usage_SurfToSurf(ps, strlen(argv[kar]) > 3 ? 2:1); exit (0); } SUMA_SKIP_COMMON_OPTIONS(brk, kar); if (!brk && (strcmp(argv[kar], "-debug") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a number after -debug \n"); exit (1); } Opt->debug = atoi(argv[++kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-node_debug") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a number after -node_debug \n"); exit (1); } Opt->NodeDbg = atoi(argv[++kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-node_indices") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a parameter after -node_indices \n"); exit (1); } Opt->in_nodeindices = argv[++kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-closest_possible") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a number after -closest_possible \n"); exit (1); } Opt->iopt = atoi(argv[++kar]); if (Opt->iopt != 0 && Opt->iopt != 1 && Opt->iopt != 2 && Opt->iopt != 3) { SUMA_S_Errv("Must choose from 0, 1, 2, or 3 for -closest_possible." " Have %d\n", Opt->iopt); exit (1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-output_params") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need at least one parameter after output_params \n"); exit (1); } accepting_out = YUP; brk = YUP; } if (!brk && accepting_out && (strcmp(argv[kar], "NearestNode") == 0)) { if (Opt->NearestNode < 1) Opt->NearestNode = 1; brk = YUP; } if (!brk && accepting_out && (strcmp(argv[kar], "NearestTriangleNodes") == 0)) { if (Opt->NearestNode < 3) Opt->NearestNode = 3; brk = YUP; } if (!brk && accepting_out && (strcmp(argv[kar], "NearestTriangle") == 0)) { if (Opt->NearestTriangle < 1) Opt->NearestTriangle = 1; brk = YUP; } if (!brk && accepting_out && (strcmp(argv[kar], "DistanceToSurf") == 0)) { Opt->DistanceToMesh = 1; brk = YUP; } if (!brk && accepting_out && (strcmp(argv[kar], "ProjectionOnSurf") == 0)) { Opt->ProjectionOnMesh = 1; brk = YUP; } if (!brk && accepting_out && (strcmp(argv[kar], "NearestNodeCoords") == 0)) { Opt->NearestNodeCoords = 1; brk = YUP; } if (!brk && accepting_out && (strcmp(argv[kar], "Data") == 0)) { if (Opt->Data < 0) { fprintf (SUMA_STDERR, "Cannot mix parameter Data with -dset option \n"); exit (1); } Opt->Data = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-data") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a name after -data \n"); exit (1); } ++kar; if (strcmp(argv[kar],"_XYZ_") == 0) { /* default Opt->in_name = NULL*/ if (Opt->in_name) { SUMA_SL_Err("Input already specified." "Do not mix -data and -dset"); exit (1); } } else { Opt->in_name = SUMA_copy_string(argv[kar]); } Opt->Data = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-dset") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a name after -dset \n"); exit (1); } ++kar; if (strcmp(argv[kar],"_XYZ_") == 0 || Opt->Data > 0) { /* default Opt->in_name = NULL*/ if (Opt->in_name || Opt->Data > 0) { SUMA_SL_Err("Input already specified." "Do not mix -data and -dset." "Or use parameter DATA with -dset"); exit (1); } } else { Opt->in_name = SUMA_copy_string(argv[kar]); } Opt->Data = -1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-prefix") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a name after -prefix \n"); exit (1); } Opt->out_prefix = SUMA_RemoveDsetExtension_eng(argv[++kar], &(Opt->oform)); brk = YUP; } if (!brk && (strcmp(argv[kar], "-mapfile") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a name after -mapfile \n"); exit (1); } Opt->s = SUMA_Extension(argv[++kar],".niml.M2M", NOPE); if (!SUMA_filexists(Opt->s)) { SUMA_S_Errv("File %s not found\n" , Opt->s); exit(1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-proj_dir") == 0)) { if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need a name after -proj_dir \n"); exit (1); } Opt->in_1D = argv[++kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-make_consistent") == 0)) { Opt->fix_winding = 1; brk = YUP; } if (!brk && !ps->arg_checked[kar]) { fprintf (SUMA_STDERR, "Error %s:\n" "Option %s not understood. Try -help for usage\n", FuncName, argv[kar]); suggest_best_prog_option(argv[0], argv[kar]); exit (1); } else { brk = NOPE; kar ++; } } /* set default for NearestNode if nothing has been set */ if (Opt->NearestNode < 1) Opt->NearestNode = 3; if (!Opt->out_prefix) Opt->out_prefix = SUMA_copy_string("SurfToSurf"); if (Opt->in_1D && Opt->s) { SUMA_S_Err("Cannot use -proj_dir along with -mapfile"); exit(1); } SUMA_RETURN(Opt); }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"MakeColorMap"}; char *fscolutname = NULL, *FidName = NULL, *Prfx = NULL, h[9], *StdType=NULL, *dbfile=NULL, *MapName=NULL; int Ncols = 0, N_Fid = 0, kar, i, ifact, *Nind = NULL, imap = -1, MapSpecified = 0; int fsbl0, fsbl1, showfscolut, exists=0; float **Fid=NULL, **M=NULL; MRI_IMAGE *im = NULL; float *far=NULL; int AfniHex=0, freesm; int suc, idISi=0; char stmp[256], *s=NULL, *ooo=NULL, *sdset_prefix; SUMA_PARSED_NAME *sname=NULL; NI_group *ngr=NULL; SUMA_Boolean brk, SkipLast, PosMap, Usage1, Usage2, Usage3, Usage4, flipud, fscolut, LocalHead = NOPE; SUMA_COLOR_MAP *SM=NULL; SUMA_DSET_FORMAT iform; SUMA_DSET *sdset=NULL; SUMA_STANDALONE_INIT; SUMA_mainENTRY; if (argc < 2) { SUMA_MakeColorMap_usage(); exit (0); } kar = 1; freesm = 1; fscolutname = NULL; fsbl0 = -1; fsbl1 = -1; brk = NOPE; SkipLast = NOPE; AfniHex = 0; PosMap = NOPE; Usage1 = NOPE; Usage2 = NOPE; Usage3 = NOPE; Usage4 = NOPE; flipud = NOPE; fscolut = NOPE; showfscolut = 0; MapSpecified = NOPE; idISi=0; iform = SUMA_NO_DSET_FORMAT; sdset_prefix=NULL; while (kar < argc) { /* loop accross command ine options */ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { SUMA_MakeColorMap_usage(); exit (0); } SUMA_SKIP_COMMON_OPTIONS(brk, kar); if (!brk && (strcmp(argv[kar], "-v") == 0)) { LocalHead = NOPE; brk = YUP; } if (!brk && (strcmp(argv[kar], "-flipud") == 0)) { flipud = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-f") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -f "); exit (1); } FidName = argv[kar]; Usage1 = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-fscolutfile") == 0)) { Usage4=YUP; kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 argument after -fscolutfile "); exit (1); } fscolutname = argv[kar]; if (fsbl0 < 0) { fsbl0 = 0; fsbl1 = 255; } brk = YUP; } if (!brk && (strcmp(argv[kar], "-usercolutfile") == 0)) { Usage4=YUP; kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 argument after -fscolutfile "); exit (1); } fscolutname = argv[kar]; if (fsbl0 < 0) { fsbl0 = 0; fsbl1 = -1; } idISi=1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-fscolut") == 0)) { fscolut = YUP; Usage4=YUP; kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need 2 arguments after -fscolut "); exit (1); } fsbl0 = atoi(argv[kar]); ++kar; fsbl1 = atoi(argv[kar]); if (fsbl0 > fsbl1 || fsbl0 < -1 || fsbl1 > 10000) { SUMA_S_Errv("-fscolut values of %d and %d either\n" "do not make sense or exceed range 0 to 10000\n", fsbl0, fsbl1); exit(1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-show_fscolut") == 0)) { showfscolut = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-fn") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -fn "); exit (1); } FidName = argv[kar]; Usage2 = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-nc") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -nc "); exit (1); } Ncols = atoi(argv[kar]); Usage1 = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-ah") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -ah "); exit (1); } Prfx = argv[kar]; AfniHex = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-ahc") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -ahc "); exit (1); } Prfx = argv[kar]; AfniHex = 2; brk = YUP; } if (!brk && (strcmp(argv[kar], "-suma_cmap") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -suma_cmap"); exit (1); } Prfx = argv[kar]; AfniHex = 3; brk = YUP; } if (!brk && (strcmp(argv[kar], "-std") == 0)) { kar ++; if (MapSpecified) { SUMA_S_Err( "Color map already specified.\n" "-cmap and -std are mutually exclusive\n"); exit (1); } if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -std "); exit (1); } MapSpecified = YUP; StdType = argv[kar]; Usage3 = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-cmapdb") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -cmapdb "); exit (1); } SUMAg_CF->isGraphical = YUP; /* WILL NEED X DISPLAY TO RESOLVE COLOR NAMES */ dbfile = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-cmap") ==0)) { if (MapSpecified) { SUMA_S_Err( "Color map already specified.\n" "-cmap and -std are mutually exclusive\n"); exit (1); } MapSpecified = YUP; kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 arguments after -cmap "); exit (1); } Usage3 = YUP; MapName = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-sl") == 0)) { SkipLast = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-pos") == 0)) { /* obsolete */ PosMap = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-sdset") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need surface dataset after -sdset \n"); exit (1); } iform = SUMA_NO_DSET_FORMAT; if (!(sdset = SUMA_LoadDset_s (argv[kar], &iform, 0))) { SUMA_S_Err("Failed to load surface dset"); exit(1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-sdset_prefix") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need prefix dataset after -sdset_prefix \n"); exit (1); } sdset_prefix = argv[kar]; brk = YUP; } if (!brk) { SUMA_S_Errv("Option %s not understood. Try -help for usage\n", argv[kar]); suggest_best_prog_option(argv[0], argv[kar]); exit (1); } else { brk = NOPE; kar ++; } }/* loop accross command ine options */ /* check input */ if ( (Usage1 && (Usage2 || Usage3 || Usage4)) || (Usage2 && (Usage1 || Usage3 || Usage4)) || (Usage3 && (Usage1 || Usage2 || Usage4)) || (Usage4 && (Usage1 || Usage2 || Usage3)) ) { SUMA_S_Err("Mixing options from multiple usage modes.\n"); exit(1); } if (!Usage1 && !Usage2 && !Usage3 && !Usage4) { SUMA_S_Err("One of these options must be used:\n" "-f, -fn, -std, or -fscolut.\n"); exit(1); } /* are there database files to read */ if (dbfile) { SUMA_LH("Now trying to read db file"); if (!SUMAg_CF->scm) { SUMAg_CF->scm = SUMA_Build_Color_maps(); if (!SUMAg_CF->scm) { SUMA_SL_Err("Failed to build color maps.\n"); exit(1); } } if (SUMA_AFNI_Extract_Colors ( dbfile, SUMAg_CF->scm ) < 0) { SUMA_S_Errv("Failed to read %s colormap file.\n", dbfile); exit(1); } } if (Usage1 || Usage2) { if (!SUMA_filexists (FidName)) { SUMA_S_Errv("File %s could not be found.\n", FidName); exit(1); } /* read the fiducials file */ im = mri_read_1D (FidName); if (!im) { SUMA_S_Err("Failed to read file"); exit(1); } far = MRI_FLOAT_PTR(im); N_Fid = im->nx * im->ny; } if (PosMap) { fprintf (SUMA_STDERR,"\nWarning %s: -pos option is obsolete.\n", FuncName); } /* allocate for fiducials */ if (Usage1) { if (N_Fid % 3) { fprintf (SUMA_STDERR, "Error %s: Not all rows in %s appear to have RGB triplets.\n", FuncName, FidName); exit (1); } Fid = (float **) SUMA_allocate2D (N_Fid / 3, 3, sizeof(float)); if (Fid == NULL) { fprintf (SUMA_STDERR, "Error %s: Could not allocate for Fid.\n", FuncName); exit(1); } for (i=0; i < im->nx; ++i) { Fid[i][0] = far[i]; Fid[i][1] = far[i+im->nx]; Fid[i][2] = far[i+2*im->nx]; } mri_free(im); im = NULL; /* now create the color map */ SM = SUMA_MakeColorMap (Fid, N_Fid/3, 0, Ncols, SkipLast, FuncName); if (SM == NULL) { fprintf (SUMA_STDERR, "Error %s: Error in SUMA_MakeColorMap.\n", FuncName); exit(1); } } if (Usage2) { /* second usage */ if (N_Fid % 4) { fprintf (SUMA_STDERR, "Error %s: Not all rows in %s appear to have " "RGB N quadruplets.\n", FuncName, FidName); exit (1); } Fid = (float **) SUMA_allocate2D (N_Fid / 4, 3, sizeof(float)); Nind = (int *) SUMA_calloc (N_Fid/4, sizeof(int)); if (Fid == NULL || !Nind) { fprintf (SUMA_STDERR, "Error %s: Could not allocate for Fid or Nind.\n", FuncName); exit(1); } for (i=0; i < im->nx; ++i) { Fid[i][0] = far[i]; Fid[i][1] = far[i+im->nx]; Fid[i][2] = far[i+2*im->nx]; Nind[i] = (int)far[i+3*im->nx]; } mri_free(im); im = NULL; /* now create the color map */ SM = SUMA_MakeColorMap_v2 (Fid, N_Fid/4, 0, Nind, SkipLast, FuncName); if (SM == NULL) { fprintf (SUMA_STDERR, "Error %s: Error in SUMA_MakeColorMap.\n", FuncName); exit(1); } Ncols = SM->N_M[0]; } if (Usage3) { /* third usage */ if (!MapName) { SM = SUMA_FindNamedColMap (StdType); freesm = 0; if (SM == NULL) { fprintf (SUMA_STDERR, "Error %s: Error in SUMA_MakeColorMap.\n", FuncName); exit(1); } Ncols = SM->N_M[0]; } else { imap = SUMA_Find_ColorMap ( MapName, SUMAg_CF->scm->CMv, SUMAg_CF->scm->N_maps, -2); if (imap < 0) { fprintf (SUMA_STDERR, "Error %s: Could not find colormap %s.\n", FuncName, MapName); exit (1); } SM = SUMAg_CF->scm->CMv[imap]; Ncols = SM->N_M[0]; } } if (Usage4) { /* 4th usage */ if (!(SM = SUMA_FScolutToColorMap(fscolutname, fsbl0, fsbl1, showfscolut, idISi))) { SUMA_S_Err("Failed to get FreeSurfer colormap."); exit(1); } Ncols = SM->N_M[0]; } if (flipud) { SUMA_Flip_Color_Map (SM); } M = SM->M; if (AfniHex && Ncols > 20) { if (!Usage4) { SUMA_S_Note("Writing colormap in colorscale format.\n"); } } if (!AfniHex) { SUMA_disp_mat (M, Ncols, 3, 1); /*SUMA_Show_ColorMapVec (&SM, 1, NULL, 2);*/ } else { if (Usage4 || Ncols > 20) { if (AfniHex == 1) { fprintf (stdout, "%s \n", Prfx); for (i=0; i < Ncols; ++i) { /* Now create the hex form */ r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][0]*255)), 1, 0); fprintf (stdout, "#%s", h); r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][1]*255)), 1, 0); fprintf (stdout, "%s", h); r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][2]*255)), 1, 0); fprintf (stdout, "%s \n", h); } fprintf (stdout, "\n") ; } else if (AfniHex == 2){ /* to go in the C code (see pbardef.h and pbar.c)*/ char *p2 = SUMA_copy_string(Prfx); SUMA_TO_UPPER(p2); fprintf (stdout, "static char %s[] = {\n \"%s \"\n \"", p2, Prfx); SUMA_free(p2); p2 = NULL; for (i=0; i < Ncols; ++i) { if (i) { if (!(i % 4)) { fprintf (stdout, " \"\n \""); } else { fprintf (stdout, " "); } } /* Now create the hex form */ r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][0]*255)), 1, 0); fprintf (stdout, "#%s", h); r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][1]*255)), 1, 0); fprintf (stdout, "%s", h); r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][2]*255)), 1, 0); fprintf (stdout, "%s", h); } fprintf (stdout, " \"\n};\n") ; } else if (AfniHex == 3){ SUMA_LHv("Now turn %s to niml\n", SM->Name); sname = SUMA_ParseFname(Prfx, NULL); snprintf(stmp, 128*sizeof(char), "file:%s.niml.cmap", sname->FileName_NoExt); if (SM->Name) SUMA_free(SM->Name); SM->Name = SUMA_copy_string(sname->FileName_NoExt); ngr = SUMA_CmapToNICmap(SM); NEL_WRITE_TX(ngr, stmp, suc); if (!suc) { SUMA_S_Errv("Failed to write %s\n", stmp); } SUMA_Free_Parsed_Name(sname); sname = NULL; } else { SUMA_S_Err("AfniHex should be 0, 1, or 2\n"); exit(1); } } else { fprintf (stdout, "\n***COLORS\n"); for (i=0; i < Ncols; ++i) { /* Now create the hex form */ r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][0]*255)), 1, 0); if (i<10) fprintf (stdout, "%s_0%d = #%s", Prfx, i, h); else fprintf (stdout, "%s_%d = #%s", Prfx, i, h); r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][1]*255)), 1, 0); fprintf (stdout, "%s", h); r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][2]*255)), 1, 0); fprintf (stdout, "%s\n", h); } /* color map */ fprintf (stdout, "\n***PALETTES %s [%d]\n//1 to -1 range\n", Prfx, Ncols); ifact = 2; for (i=0; i < Ncols; ++i) { fprintf (stdout, "%f -> ", 1.0 - (float)(ifact*i)/Ncols); if (i<10) fprintf (stdout, "%s_0%d\n", Prfx, i); else fprintf (stdout, "%s_%d\n", Prfx, i); } fprintf (stdout, "\n***PALETTES %s [%d+]\n//1 to 0 range\n", Prfx, Ncols); ifact = 1; for (i=0; i < Ncols; ++i) { fprintf (stdout, "%f -> ", 1.0 - (float)(ifact*i)/Ncols); if (i<10) fprintf (stdout, "%s_0%d\n", Prfx, i); else fprintf (stdout, "%s_%d\n", Prfx, i); } } } /* free allocated space */ if (Usage1) { if (Fid) SUMA_free2D((char **)Fid, N_Fid / 3); } else { if (Fid) SUMA_free2D((char **)Fid, N_Fid / 4); if (Nind) SUMA_free(Nind); } /* add colormap to a surface dset ? */ if (sdset) { SUMA_DSET *idset; if (!SUMA_is_AllConsistentCastType_dset(sdset, SUMA_int)) { idset = SUMA_CoercedCopyofDset(sdset, SUMA_int, NULL); } else { idset = sdset; } if (!(SUMA_dset_to_Label_dset_cmap(idset, SM))) { SUMA_S_Err("Failed to make change"); exit(1); } s = SUMA_OutputDsetFileStatus( sdset_prefix?sdset_prefix:SDSET_FILENAME(sdset), NULL, &iform, NULL, ".lbl", &exists); SUMA_AddNgrHist(sdset->ngr, FuncName, argc, argv); ooo = SUMA_WriteDset_s(s, idset, iform, THD_ok_overwrite(), 0); SUMA_free(ooo); ooo=NULL; SUMA_free(s); s = NULL; if (idset != sdset) SUMA_FreeDset(idset); SUMA_FreeDset(sdset); sdset=NULL; } if (SM && !MapName && freesm) SUMA_Free_ColorMap(SM); if (!SUMA_Free_CommonFields(SUMAg_CF)) { SUMA_SL_Err("Failed to free commonfields."); } SUMA_RETURN (0); }
char * SUMA_BrainVoyager_Read_vmr(char *fnameorig, THD_3dim_dataset *dset, int LoadData, byte Qxforce, byte bsforce, int viewforce, char *outname) { static char FuncName[]={"SUMA_BrainVoyager_Read_vmr"}; int i = 0, nf, iop, dchunk, End, bs, doff, ex, data_type=SUMA_notypeset, view, endian, dblock; THD_ivec3 iv3; unsigned long len; short qxver; short nvox[3]; /* values are unsigned, so check for sign for bs... */ THD_mat33 m33; THD_ivec3 orixyz , nxyz ; THD_fvec3 dxyz , orgxyz ; float ep[3], sp[3]; char sview[10], *fname = NULL, *scom=NULL, form[10], swp[10], orstr[10], xfov[100], yfov[100], zfov[100], *prefix = NULL, *dsetheadname = NULL; FILE *fid = NULL; SUMA_Boolean LocalHead = NOPE; SUMA_ENTRY; if (!dset || !fnameorig) { SUMA_SL_Err("NULL fname || NULL dset!"); SUMA_RETURN(NOPE); } if (!SUMA_isExtension(fnameorig, ".vmr")) { SUMA_SL_Err("vmr dset is expected to have .vmr for an extension"); SUMA_RETURN(NOPE); } if (!SUMA_filexists(fnameorig)) { SUMA_SL_Err("file does not exist"); SUMA_RETURN(NOPE); } /* make fname be the new name without the extension*/ if (!outname) { fname = SUMA_Extension(fnameorig,".vmr", YUP); } else { fname = SUMA_Extension(outname, ".vmr", YUP); } prefix = SUMA_AfniPrefix(fname, NULL, NULL, NULL); if( !THD_filename_ok(prefix) ) { SUMA_SL_Err("Bad prefix"); goto CLEAN_EXIT; } /* someday, guess format on your own...*/ qxver = 0; if (Qxforce) { SUMA_LH("Forcing qxver"); qxver = 1; /* set to 1 if qx format */ } /* view ? */ SUMA_LHv("Viewforce = %d; [%d %d]\n", viewforce, VIEW_ORIGINAL_TYPE, VIEW_TALAIRACH_TYPE); if (viewforce >= VIEW_ORIGINAL_TYPE && viewforce <= VIEW_TALAIRACH_TYPE) { view = viewforce; } else { view = VIEW_ORIGINAL_TYPE; if (SUMA_iswordin_ci(fnameorig, "_tal") == 1) { view = VIEW_TALAIRACH_TYPE; } else if (SUMA_iswordin_ci(fnameorig, "_acpc") == 1) { view = VIEW_ACPCALIGNED_TYPE; } else { view = VIEW_ORIGINAL_TYPE; } } switch (view) { case VIEW_ORIGINAL_TYPE: sprintf(sview,"+orig"); break; case VIEW_ACPCALIGNED_TYPE: sprintf(sview,"+acpc"); break; case VIEW_TALAIRACH_TYPE: sprintf(sview,"+tlrc"); break; default: SUMA_SL_Err("Bad view"); goto CLEAN_EXIT; } if (LocalHead) fprintf(SUMA_STDERR,"%s: View %s, %d\n", FuncName, sview, view); dsetheadname = SUMA_append_replace_string(prefix,".HEAD", sview, 0); if (SUMA_filexists(dsetheadname)) { SUMA_S_Errv("Bad prefix, output dset %s exists\n", dsetheadname); goto CLEAN_EXIT; } SUMA_free(dsetheadname); dsetheadname = NULL; fid = fopen(fnameorig,"r"); if (!fid) { SUMA_SL_Err("Could not open file for reading"); goto CLEAN_EXIT; } if (qxver) { SUMA_LH("Reading dimensions, 2+ 1st 6 bytes and deciding on swap"); doff = 4*sizeof(short);/* data offset 2 + 6 bytes */ } else { SUMA_LH("Reading dimensions, 1st 6 bytes and deciding on swap"); doff = 3*sizeof(short);/* data offset */ } SUMA_WHAT_ENDIAN(endian); bs = 0; swp[0] = '\0'; data_type = SUMA_byte; /* voxel data is bytes */ dchunk = sizeof(byte); /* voxel data is bytes */ sprintf(form,"3Db"); if (qxver) { SUMA_READ_NUM(&(qxver), fid, ex, sizeof(short)); if (LocalHead) fprintf(SUMA_STDERR,"%s: QXver = %d\n", FuncName, qxver);}/* is this a QX format?*/ SUMA_READ_NUM(&(nvox[2]), fid, ex, sizeof(short)); /* Z first */ SUMA_READ_NUM(&(nvox[1]), fid, ex, sizeof(short)); SUMA_READ_NUM(&(nvox[0]), fid, ex, sizeof(short)); if ((nvox[0] < 0 || nvox[1] < 0 || nvox[2] < 0 )) { SUMA_LH("Byte swapping needed"); bs = 1; } if (bsforce) { SUMA_LH("Byte swapping forced"); bs = 1; } if (bs) { if (qxver) SUMA_swap_2(&(qxver)); SUMA_swap_2(&(nvox[0])); SUMA_swap_2(&(nvox[1])); SUMA_swap_2(&(nvox[2])); sprintf(swp,"-2swap"); SUMA_OTHER_ENDIAN(endian); } /* 1 1 1???? */ if (nvox[0] == nvox[1] && nvox[1] == nvox[2] && nvox[2] == 1) { if (LocalHead) { fprintf(SUMA_STDERR,"Warning %s: Voxel nums all 1. Trying from file size\n", FuncName); } len = THD_filesize( fnameorig ) ; len -= doff; len /= dchunk; nvox[0] = (int)pow((double)len, 1.0/3.0); if (nvox[0] * nvox[0] * nvox[0] != len) { fprintf(SUMA_STDERR,"Error %s: Bad voxel numbers and could not infer number from filesize.\n" "Size of file: %lld, data offset: %d, datum size: %d, data number: %ld\n" "Inferred nvox:%d\n", FuncName, THD_filesize( fnameorig ), doff, dchunk, len, nvox[0]); goto CLEAN_EXIT; } nvox[2] = nvox[1] = nvox[0]; if (LocalHead) { fprintf(SUMA_STDERR,"Warning %s: Using filesize inferred number of voxels: %d %d %d\n", FuncName, nvox[0], nvox[1], nvox[2]); } } if (LocalHead) fprintf(SUMA_STDERR,"Number of voxels: %d %d %d. qxver %d\n", nvox[0], nvox[1], nvox[2], qxver); /* check against filesize */ len = THD_filesize( fnameorig ) ; dblock = nvox[0]*nvox[1]*nvox[2]*dchunk; if (len != (dblock + doff)) { if (!qxver) { fprintf(SUMA_STDERR, "Mismatch between file size %ld\n" "and expected size %d = (%d*%d*%d*%d+%d) \n", len, (dblock + doff), nvox[0], nvox[1], nvox[2], dchunk, doff); goto CLEAN_EXIT; }else if (len < dblock + doff) { fprintf(SUMA_STDERR, "Mismatch between file size %ld\n" "and minimum expected size %d = (%d*%d*%d*%d+%d) \n", len, (dblock + doff), nvox[0], nvox[1], nvox[2], dchunk, doff); goto CLEAN_EXIT; }else { SUMA_LH("Proceeding"); } } if (LocalHead) fprintf(SUMA_STDERR,"File size passes test\n"); /* orientation */ orixyz.ijk[0] = ORI_A2P_TYPE; orixyz.ijk[1] = ORI_S2I_TYPE; orixyz.ijk[2] = ORI_R2L_TYPE; /* load number of voxels */ LOAD_IVEC3( nxyz , nvox[0] , nvox[1] , nvox[2] ) ; /* form the command */ SUMA_LH("Forming command"); { float delta[3]={1.0, 1.0, 1.0}; float origin[3]={0.0, 0.0, 0.0}; /* set origin of 0th voxel*/ origin[0] = (float)((nvox[0]*delta[0]))/2.0; /* ZSS: Changed from 0 0 0 Nov 1 07 */ origin[1] = (float)((nvox[1]*delta[1]))/2.0; origin[2] = (float)((nvox[2]*delta[2]))/2.0; /* dimensions, same for vmr*/ LOAD_FVEC3( dxyz , delta[0], delta[1], delta[2] ) ; SUMA_sizeto3d_2_deltaHEAD(orixyz, &dxyz); /* origin */ LOAD_FVEC3( orgxyz , origin[0], origin[1], origin[2] ) ; SUMA_originto3d_2_originHEAD(orixyz, &orgxyz); } /* start point (edge of origin voxel) and end point (opposite to start ) */ sp[0] = orgxyz.xyz[0] + SUMA_ABS(dxyz.xyz[0]) / 2.0; sp[1] = orgxyz.xyz[1] + SUMA_ABS(dxyz.xyz[1]) / 2.0; sp[2] = orgxyz.xyz[2] + SUMA_ABS(dxyz.xyz[2]) / 2.0; ep[0] = orgxyz.xyz[0] + (nxyz.ijk[0] - 0.5) * SUMA_ABS(dxyz.xyz[0]); ep[1] = orgxyz.xyz[1] + (nxyz.ijk[1] - 0.5) * SUMA_ABS(dxyz.xyz[1]); ep[2] = orgxyz.xyz[2] + (nxyz.ijk[2] - 0.5) * SUMA_ABS(dxyz.xyz[2]); SUMA_orcode_to_orstring (orixyz.ijk[0], orixyz.ijk[1], orixyz.ijk[2], orstr); sprintf(xfov," -xFOV %.2f%c-%.2f%c", sp[0], orstr[0], ep[0], orstr[3]); sprintf(yfov," -yFOV %.2f%c-%.2f%c", sp[1], orstr[1], ep[1], orstr[4]); sprintf(zfov," -zFOV %.2f%c-%.2f%c", sp[2], orstr[2], ep[2], orstr[5]); scom = (char *)SUMA_calloc((strlen(fnameorig)+500), sizeof(char)); sprintf(scom,"to3d %s %s %s %s -prefix %s %s:%d:0:%d:%d:%d:%s ", swp, xfov, yfov, zfov, prefix, form, doff, nvox[0], nvox[1], nvox[0], fnameorig); SUMA_LH("HERE"); if (dset) { /* form the dset header */ int nvals_read = 0; SUMA_LH("Filling header"); EDIT_dset_items( dset , ADN_prefix , prefix , ADN_datum_all , data_type , ADN_nxyz , nxyz , ADN_xyzdel , dxyz , ADN_xyzorg , orgxyz , ADN_xyzorient , orixyz , ADN_malloc_type , DATABLOCK_MEM_MALLOC , ADN_view_type , view , ADN_type , HEAD_ANAT_TYPE , ADN_func_type , ANAT_BUCK_TYPE , ADN_none ) ; if (LoadData) { void *vec=NULL; SUMA_LH("Loading data"); if (!(vec = SUMA_BinarySuck(fnameorig, data_type, endian, 3*sizeof(short), -1, &nvals_read))) { SUMA_SL_Err("Failed to read data file"); goto CLEAN_EXIT; } if (qxver) { if (nvals_read < nvox[0]*nvox[1]*nvox[2]) { SUMA_SL_Warn("Failed to read expected number of voxels\n proceeding..."); } } else { if (nvals_read != nvox[0]*nvox[1]*nvox[2]) { SUMA_SL_Warn("Failed to read the appropriate number of voxels\n proceeding..."); } } EDIT_substitute_brick( dset , 0 , data_type , vec) ; if (LocalHead) fprintf(SUMA_STDERR,"%s: Read %d values from file.\n", FuncName, nvals_read); /* DSET_write(dset) ; */ } } CLEAN_EXIT: if (prefix) SUMA_free(prefix); prefix = NULL; if (fname) SUMA_free(fname); fname = NULL; if (fid) fclose(fid); fid = NULL; SUMA_RETURN(scom); }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"SampBias"}; int N_Spec = -1; int i; SUMA_SurfaceObject *SO = NULL; SUMA_SurfSpecFile *Spec; SUMA_GENERIC_ARGV_PARSE *ps=NULL; void *SO_name = NULL; SUMA_DSET *dset=NULL; SUMA_Boolean LocalHead = NOPE; SUMA_KUBATEST_OPTIONS Opt; 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;-spec;-sv;-s;-o;"); SUMA_SampBias_ParseInput (argv, argc, &Opt, ps); if (argc < 4) { SUMA_S_Err("Too few arguments"); exit (0); } /* read surface */ Spec = SUMA_IO_args_2_spec(ps, &N_Spec); if (N_Spec == 0) { SUMA_S_Err("No surfaces found."); exit(1); } SUMA_LH("Loading surface..."); SO = SUMA_Load_Spec_Surf_with_Metrics(Spec, 0, ps->sv[0], Opt.debug); if (!SO) { fprintf (SUMA_STDERR,"Error %s:\n" "Failed to find surface\n" "in spec file. \n", FuncName ); exit(1); } if (!(dset = calcWithOffsets(SO, &Opt))) { SUMA_S_Err("Failed to calc ratios"); exit(1); } if (!SUMA_AddNgrHist(dset->ngr, "SampBias", argc, argv)) { SUMA_S_Err("Failed to add history"); } if (Opt.prefix) { char *cc = SUMA_WriteDset_s(Opt.prefix, dset, SUMA_NO_DSET_FORMAT, 1,1); if (cc) SUMA_free(cc); } SUMA_LH("clean up"); if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) { SUMA_SL_Err("DO Cleanup Failed!"); } if (Opt.outfile) SUMA_free(Opt.outfile); if (Opt.histnote) SUMA_free(Opt.histnote); if (Opt.prefix) SUMA_free(Opt.prefix); if (Opt.segdo) SUMA_free(Opt.segdo); if (!SUMA_FreeSpecFields(Spec)) { SUMA_S_Err("Failed to free SpecFields"); } SUMA_free(Spec); Spec = NULL; if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL; if (!SUMA_Free_CommonFields(SUMAg_CF)) { SUMA_SL_Err("SUMAg_CF Cleanup Failed!");} SUMA_RETURN(0); }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"SpharmReco"}; SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt; SUMA_GENERIC_ARGV_PARSE *ps=NULL; SUMA_SurfSpecFile *Spec = NULL; int *isin=NULL; int i = -1, ii, jj, kk, il, N_Spec=0, i3, OK, l, lc, ncol=0, nrow=0, dims[20], N_dims=0, N_surfs=0, j, j_l; SUMA_Boolean exists=NOPE; float *far=NULL, *xbuf=NULL, *ybuf=NULL, *zbuf=NULL; double *dv=NULL, fac = 0.0; complex *cv=NULL; SUMA_FORM_AFNI_DSET_STRUCT *OptDs = NULL; SUMA_SurfaceObject *SO = NULL, *SOt=NULL; SUMA_VOLPAR *vp = NULL; SUMA_MX_VEC *y_l=NULL, *y_l_t=NULL; SUMA_MX_VEC *betal=NULL; SUMA_MX_VEC *xe=NULL, *sm=NULL, *yc=NULL; SUMA_MX_VEC **axe=NULL, **abeta=NULL; char *oname=NULL, stmp[100], *pref=NULL; SUMA_SO_File_Format form=SUMA_FF_NOT_SPECIFIED; SUMA_SO_File_Type tp=SUMA_FT_NOT_SPECIFIED; SUMA_OPT_SPHERICAL_BASES optb; void *SO_name=NULL; struct timeval tt; int oform= SUMA_NO_DSET_FORMAT; char *ooo=NULL; float *fbuf=NULL; SUMA_DSET *out_dset = NULL; SUMA_Boolean do_surf_xyz = NOPE; 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;-spec;-talk;-o;"); if (argc < 2) { usage_SpharmReco(ps); exit (1); } Opt = SUMA_SpharmReco_ParseInput (argv, argc, ps); if (Opt->debug) LocalHead = YUP; if (Opt->n_in_namev < 1) { SUMA_S_Err("No Coef!"); exit (1); } if (ps->o_N_surfnames) do_surf_xyz = YUP; if (!ps->o_N_surfnames && !Opt->out_prefix) { SUMA_S_Notev("Using default prefix of %s\n", "spharm_sm"); Opt->out_prefix = SUMA_copy_string("spharm_sm"); } if ((Opt->n_in_namev % 3) && do_surf_xyz) { SUMA_S_Errv("Number of coefficient options (%d) must be\n" "a multiple of three if output is \n" "to be treated as x, y, z coordinates\n", Opt->n_in_namev); exit(1); } /* decide on output form */ if (Opt->out_prefix) { oform = SUMA_GuessFormatFromExtension(Opt->out_prefix,"something.1D.dset"); } if (Opt->debug > 2) LocalHead = YUP; /* check on inputs */ optb.SOu=NULL; optb.BasesFileRoot=Opt->bases_prefix; optb.SaveBases=Opt->bases_prefix; optb.debug = Opt->debug; N_surfs = ps->s_N_surfnames + ps->i_N_surfnames + ps->t_N_surfnames; if (( N_surfs != 1)) { SUMA_S_Errv("You must provide only one surface.\n" "Have %d on command line.\n", N_surfs); exit(1); } Spec = SUMA_IO_args_2_spec(ps, &N_Spec); if (N_Spec == 0) { SUMA_S_Err("No surfaces found."); exit(1); } if (N_Spec != 1) { SUMA_S_Err("Multiple spec at input."); exit(1); } for (i=0; i<N_surfs; ++i) { SO = SUMA_Load_Spec_Surf(Spec, i, ps->sv[i], 0); if (!SO) { fprintf (SUMA_STDERR,"Error %s:\n" "Failed to find surface\n" "in spec file. \n", FuncName ); exit(1); } if (Opt->debug > 2) SUMA_Print_Surface_Object(SO, SUMA_STDERR); if (!SO->normdir) SO->normdir = 1; /* set it to something */ SOt = SUMA_CreateChildSO( SO, NULL, -1, NULL, -1, 0); if (!SOt->State) {SOt->State = SUMA_copy_string("spharm_domain"); } if (!SOt->Group) {SOt->Group = SUMA_copy_string("spharm_domain"); } } /* see if SUMA talk is turned on */ if (ps->cs->talk_suma) { ps->cs->istream = SUMA_GEOMCOMP_LINE; if (!SUMA_SendToSuma (SO, ps->cs, NULL, SUMA_NO_DSET_TYPE, 0)) { SUMA_SL_Err("Failed to initialize SUMA_SendToSuma"); ps->cs->Send = NOPE; ps->cs->talk_suma = NOPE; } SUMA_SendSumaNewSurface(SO, ps->cs); } /* Number of coefficients */ axe = (SUMA_MX_VEC **)SUMA_calloc(Opt->n_in_namev, sizeof(SUMA_MX_VEC*)); abeta = (SUMA_MX_VEC **)SUMA_calloc(Opt->n_in_namev, sizeof(SUMA_MX_VEC*)); /* initialize output variables */ for (i=0; i<Opt->n_in_namev; ++i) { dims[0] = SO->N_Node; dims[1] = 1; N_dims = 2; axe[i] = SUMA_NewMxVec(SUMA_double, 2, dims, 1); if (Opt->debug > 1) SUMA_ShowMxVec(axe[i], 1, NULL, "\naxe[i]\n"); N_dims = -1; /* take whatever is in file, otherwise, should setup dims[0] and dims[1] */ abeta[i] = SUMA_Read1DMxVec(SUMA_double, Opt->in_namev[i], dims, &N_dims); if (Opt->debug > 1) SUMA_ShowMxVec(abeta[i], 1, NULL, "\nabeta[i]\n"); } SUMA_Spherical_Bases(&l, NULL); /* init SUMA_Spherical_Bases */ /* start timer*/ SUMA_etime2(FuncName, NULL, NULL); /* A record of matrices and processes to follow for spharm reconstruction Here y_l, for each l, and beta are loaded from files created by SpharmDeco N_Node : Number of points in parametrization of sphere sigma : the smoothing kernel 0 == No smoothing, 0.01 (quite a bit of smoothing). the higher the sigma the more the attenuation of higher degree harmonics. for l = 0; y_l : l th degree harmonic complex l+1 x N_Node turned to real since imaginary is all 0 y_l_t : y_l' double N_Node x l+1 XX vt : y_l * y_l_t double l+1 x l+1 XX vt2 : inv(vt) double l+1 x l+1 XX Ycommon : vt2 * y_l double l+1 x N_Node XX betal : Ycommon * x double l+1 x 1 betal : filled from beta(l,0:2l) double l+1 x 1 (beta(0,0), really) xe : y_l_t * betal double N_Node x 1 for l > 0; y_l : l th degree harmonic complex l+1 x N_Node turned to real of dimensions: double 2*l+1 x N_Node where the imaginary part of y_l is appended below the real part y_l_t : y_l' double N_Node x 2*l+1 XX vt : y_l * y_l_t double 2*l+1 x 2*l+1 XX vt2 : inv(vt) double 2*l+1 x 2*l+1 XX Ycommon : vt2 * y_l double 2*l+1 x N_Node XX dif_vec_x: x - xe double N_Node x 1 betal : filled from beta(l,0:2l) double 2*l+1 x 1 sm : y_l_t * betal double N_Node x 1 fac : exp((-l*(l+1))*sigma) double 1 x 1 xe : xe + fac * sm double N_Node x 1 xe is the estimate of x up to order l harmonics beta : lower triangular matrix where betal double l+1 x 2l+1 are stored for all l degrees */ l=0; do { lc = l; y_l = SUMA_Spherical_Bases(&lc, &optb); /* y_l is equal to Y' in Moo's SPHARsmooth.m function */ if (lc < l) { /* The function will read in the bases from disk */ Opt->iopt = lc; /* y_l is a (l+1 x N_Node) complex matrix. */ SUMA_S_Notev("Cannot go for order higher than %d\n.", lc); goto NEXT_L; } do { if (SO) { if ((LocalHead && l == 0) || Opt->debug > 1) SUMA_S_Notev("Using the mesh from %s for \n" "a reconstruction of degree %d.\n", SO->Label, l); if (Opt->debug > 2) SUMA_Print_Surface_Object (SO, SUMA_STDERR); } else { SUMA_S_Err("NULL SO!!!"); exit(1); } if (LocalHead || Opt->debug > 1) { fprintf(SUMA_STDERR,"%s: Doing l = %d\n", FuncName, l); SUMA_etime2(FuncName, "Entering loop", FuncName); } if (l==0) { yc = SUMA_CoerceMxVec(y_l, SUMA_double, 0, NULL); /* for l == 0, all imaginary comp. are 0 */ y_l = SUMA_FreeMxVec(y_l); y_l = yc; yc = NULL; y_l_t = SUMA_MxVecTranspose(y_l, NULL); /* y_l is equal to Y' in Moo's SPHARsmooth.m function*/ if (Opt->debug > 1) SUMA_ShowMxVec(y_l_t, 1, NULL, "\ny_l_t matrix\n"); dims[0] = 2*l+1; dims[1] = 1; betal = SUMA_NewMxVec(SUMA_double, 2, dims, 1); for (jj=0; jj<Opt->n_in_namev; ++jj) { for (i=0;i<=2*l;++i) { mxvd2(betal,i,0) = mxvd2(abeta[jj],l, i); } if (Opt->debug > 1) SUMA_ShowMxVec(betal, 1, NULL, "\nbetal matrix\n"); xe = SUMA_MxVecMult(y_l_t, betal, NULL, 0); if (Opt->debug > 1) { SUMA_ShowMxVec(xe, 1, NULL, "\nxe vector\n"); if (Opt->debug > 2) SUMA_WriteMxVec(xe, "xe_l0.1D", "#xe vector"); } axe[jj] = xe; xe = NULL; } } else { /* higher order, need to deal with real and imaginary parts*/ /* Catenate the columns of y_l with the real columns first (negative harmonics), followed by imaginary ones (positive harms.)*/ sprintf(stmp, "Starting with order l=%d", l); if (Opt->debug) SUMA_etime2(FuncName, stmp, FuncName); y_l = SUMA_YLcomp_to_YLdoub(&y_l, Opt->debug); /* Now y_l is real */ if (Opt->debug ) SUMA_etime2(FuncName, "Created y_l", FuncName); if (Opt->debug > 2) { SUMA_WriteMxVec(y_l, "y_l.1D.dset", "#y_l real matrix\n"); } y_l_t = SUMA_MxVecTranspose(y_l, NULL); /* y_l is equal to Y' in Moo's SPHARsmooth.m function*/ if (Opt->debug > 1) SUMA_ShowMxVec(y_l_t, 1, NULL, "\ny_l_t matrix\n"); if (Opt->debug ) SUMA_etime2(FuncName, "Trasnposed y_l", FuncName); fac = exp((double)(-l*(l+1))*Opt->v0); dims[0] = 2*l+1; dims[1] = 1; betal = SUMA_NewMxVec(SUMA_double, 2, dims, 1); for (jj=0; jj<Opt->n_in_namev; ++jj) { xe = axe[jj]; for (i=0;i<=2*l;++i) { mxvd2(betal,i,0) = mxvd2(abeta[jj],l, i); } if (Opt->debug > 1) SUMA_ShowMxVec(betal, 1, NULL, "\nbetal matrix\n"); sm = SUMA_MxVecMult(y_l_t, betal, sm, 0); if (Opt->debug > 1) { sprintf(stmp,"\nsm_%d vector\n", jj); SUMA_ShowMxVec(sm , 1, NULL, stmp); } for (i=0;i<xe->N_vals;++i) { mxvd1(xe,i) += fac * mxvd1(sm,i); } if (Opt->debug > 1) { sprintf(stmp,"\n%d_estimate vector\n", jj); SUMA_ShowMxVec(xe, 1, NULL, stmp); sprintf(stmp,"%d_estimate_l%d.1D.dset", jj, l); if (Opt->debug > 2) SUMA_WriteMxVec(xe, stmp, "#estimate at last l\n"); } } if (Opt->debug) SUMA_etime2(FuncName, "Refit residual", FuncName); } /* store new coordinates, in a temp surface, fun to update as we're progressing in case want to feed suma at some point*/ if (do_surf_xyz) { if (l==0 && ps->cs->Send && Opt->debug) { SUMA_S_Warn("Assuming coefficients are XYZ of surfaces !\n" "Only the 1st three data columns will be used\n" "in talk_suma mode.\n" "Warnings muted for l > 0\n"); } for (i=0; i<SO->N_Node; ++i) { i3 = 3*i; SOt->NodeList[i3 ] = mxvd1(axe[0], i); SOt->NodeList[i3+1] = mxvd1(axe[1], i); SOt->NodeList[i3+2] = mxvd1(axe[2], i); } } if (ps->cs->Send) { /* send the smoothed coords */ if (do_surf_xyz) { /* surface coordinates */ if (l > 0) { if (Opt->debug) { SUMA_S_Notev("[%f %f %f]\n", SOt->NodeList[0], SOt->NodeList[1], SOt->NodeList[2]); } if (!SUMA_SendToSuma ( SO, ps->cs, (void *)SOt->NodeList, SUMA_NODE_XYZ, 1)) { SUMA_SL_Warn( "Failed in SUMA_SendToSuma\n" "Communication halted."); } } } else { if (l > 0) { if (!fbuf) fbuf = (float *)SUMA_malloc(SO->N_Node* sizeof(float)); for (i=0; i<SO->N_Node; ++i) fbuf[i] = mxvd1(axe[0], i); if (!SUMA_SendToSuma ( SO, ps->cs, (void *)fbuf, SUMA_NODE_RGBAb, 1)) { SUMA_SL_Warn( "Failed in SUMA_SendToSuma\n" "Communication halted."); } } } } /* Done with order l */ if (y_l) y_l = SUMA_FreeMxVec(y_l); if (y_l_t) y_l_t = SUMA_FreeMxVec(y_l_t); if (betal) betal = SUMA_FreeMxVec(betal); if (Opt->debug ) { SUMA_S_Note("MemCheck:"); MCHECK; } } while (0); NEXT_L: ++l; } while (l <= Opt->iopt); --l; /* back to where you stopped, kid */ /* Now create an output data set for the reconstructed data */ out_dset = SUMA_CreateDsetPointer( Opt->out_prefix ? Opt->out_prefix:"spharm_reco", SUMA_NODE_BUCKET, /* mix and match */ NULL, /* no idcode, let the function create one from the filename*/ NULL, /* no domain str specified */ SO->N_Node /* Number of nodes allocated for */ ); /* add results */ for (jj=0; jj<Opt->n_in_namev; ++jj) { if (!fbuf) fbuf = (float *)SUMA_malloc(SO->N_Node*sizeof(float)); for (i=0; i<SO->N_Node; ++i) fbuf[i] = mxvd1(axe[jj], i); if (!SUMA_AddDsetNelCol( out_dset, "sp_reco", SUMA_NODE_FLOAT, fbuf, NULL, 1)) { SUMA_S_Err("Failed to update output."); exit(1); } axe[jj] = SUMA_FreeMxVec(axe[jj]); } if (Opt->out_prefix) { /* write out the data */ ooo = SUMA_WriteDset_s( Opt->out_prefix, out_dset, oform, THD_ok_overwrite(), 0); if (Opt->debug) SUMA_S_Notev("Wrote %s\n", ooo); SUMA_free(ooo); ooo=NULL; } /* do we need to write out surfaces? */ if (do_surf_xyz && ps->o_N_surfnames) { for (i=0; i<Opt->n_in_namev/3; ++i) { if (ps->o_N_surfnames == Opt->n_in_namev/3) { pref = SUMA_copy_string(ps->o_surfnames[i]); tp = ps->o_FT[i]; form = ps->o_FF[i]; } else { sprintf(stmp, "s%02d", i); pref = SUMA_append_string(ps->o_surfnames[0], stmp); tp = ps->o_FT[0]; form = ps->o_FF[0]; } if (Opt->debug) { SUMA_S_Notev("Prepping to write surface %s\n" "with X Y Z from cols. %d %d %d\n" , pref, i*3, 1+i*3, 2+i*3); } xbuf = (float*)out_dset->dnel->vec[0+i*3]; ybuf = (float*)out_dset->dnel->vec[1+i*3]; zbuf = (float*)out_dset->dnel->vec[2+i*3]; for (ii=0; ii<SO->N_Node; ++ii) { i3 = 3*ii; SO->NodeList[i3 ] = xbuf[ii]; SO->NodeList[i3+1] = ybuf[ii]; SO->NodeList[i3+2] = zbuf[ii]; } /* write the surface */ SO_name = SUMA_Prefix2SurfaceName(pref, NULL, NULL, tp, &exists); if (!THD_ok_overwrite() && exists) { fprintf(SUMA_STDERR,"Warning %s:\nOutput surface %s* on disk.\n" "Will not overwrite.\n", FuncName, pref); exit(1); } if (Opt->debug) { SUMA_S_Notev("Saving surface under prefix %s\n", pref); } if (!SUMA_Save_Surface_Object (SO_name, SO, tp, form, NULL)) { SUMA_S_Err("Failed to write reconstructed surface!"); exit(1); } } } /* clean and quit */ if (fbuf) SUMA_free(fbuf); for (i=0; i<Opt->n_in_namev; ++i) { SUMA_FreeMxVec(abeta[i]); } SUMA_free(axe); axe = NULL; SUMA_free(abeta); abeta = NULL; if (sm) sm = SUMA_FreeMxVec(sm); SUMA_Spherical_Bases(&l, NULL); /* clean SUMA_Spherical_Bases */ /* you don't want to exit rapidly because the SUMA might not be done processing the last elements*/ if (ps->cs->Send && !ps->cs->GoneBad) { /* cleanup and close connections */ if (!SUMA_SendToSuma (SO, ps->cs, NULL, SUMA_NODE_XYZ, 2)) { SUMA_SL_Warn("Failed in SUMA_SendToSuma\nCleanup failed"); } } 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 (out_dset) SUMA_FreeDset(out_dset); out_dset = 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[]) {/* Main */ static char FuncName[]={"FSread_annot"}; int kar, Showct, testmode; char *fname = NULL, *fcmap = NULL, *fdset = NULL, *froi = NULL, *fcol = NULL, *ctfile=NULL, sbuf[1024]={""}; SUMA_Boolean SkipCoords = NOPE, brk; SUMA_DSET *dset=NULL; int lbl1,lbl2, ver, hemi, FSdefault; SUMA_Boolean LocalHead = NOPE; SUMA_STANDALONE_INIT; SUMA_mainENTRY; /* allocate space for CommonFields structure */ SUMAg_CF = SUMA_Create_CommonFields (); if (SUMAg_CF == NULL) { fprintf( SUMA_STDERR, "Error %s: Failed in SUMA_Create_CommonFields\n", FuncName); exit(1); } /* parse command line */ kar = 1; fname = NULL; froi = NULL; fcmap = NULL; fcol = NULL; brk = NOPE; ctfile = NULL; Showct = 0; testmode = 0; lbl1 = -1; lbl2 = -1; ver = -1; FSdefault = 0; hemi=0; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { usage_SUMA_FSread_annot_Main(); exit (0); } if (!brk && (strcmp(argv[kar], "-show_FScmap") == 0)) { Showct = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-testmode") == 0)) { testmode = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-input") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -input\n"); exit (1); } fname = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-FScmap") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -FScmap\n"); exit (1); } ctfile = argv[kar]; if (!strcmp(ctfile,"FS_DEFAULT")) { char *eee = getenv("FREESURFER_HOME"); if (!eee) { SUMA_S_Err("Environment variable FREESURFER_HOME not set.\n" "Cannot locate FreeSurferColorLUT.txt\n"); exit (1); } else { sprintf(sbuf, "%s/FreeSurferColorLUT.txt", eee); ctfile = sbuf; FSdefault = 1; SUMA_S_Notev("Using %s\n", ctfile); } } brk = YUP; } if (!brk && (strcmp(argv[kar], "-FSversion") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -FSversion\n"); exit (1); } if (strstr(argv[kar],"2009")) ver = 2009; else if (strstr(argv[kar],"2005")) ver = 2005; else { fprintf (SUMA_STDERR, "Bad value for -FSversion of %s (looking for 2005 or 2009)\n", argv[kar]); exit (1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-hemi") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -hemi\n"); exit (1); } if (strstr(argv[kar],"lh")) hemi = -1; else if (strstr(argv[kar],"rh")) hemi = 1; else { fprintf (SUMA_STDERR, "Bad value for -hemi of %s (looking for lh or rh)\n", argv[kar]); exit (1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-FScmaprange") == 0)) { kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need 2 argument after -FScmaprange\n"); exit (1); } lbl1 = atoi(argv[kar]); ++kar; lbl2 = atoi(argv[kar]); if (lbl1 > lbl2 || lbl1 < -1) { fprintf (SUMA_STDERR, "Bad value for -FScmaprange of [%d %d]\n", lbl1, lbl2); exit (1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-roi_1D") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -ROI_1D\n"); exit (1); } froi = argv[kar]; brk = YUP; } if (!brk && ( (strcmp(argv[kar], "-prefix") == 0) || (strcmp(argv[kar], "-dset") == 0) ) ) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -dset\n"); exit (1); } fdset = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-cmap_1D") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -cmap_1D\n"); exit (1); } fcmap = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-col_1D") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -col_1D\n"); exit (1); } fcol = argv[kar]; brk = YUP; } if (!brk) { fprintf (SUMA_STDERR, "Error %s:\n" "Option %s not understood. Try -help for usage\n", FuncName, argv[kar]); exit (1); } else { brk = NOPE; kar ++; } } if (!fname) { SUMA_SL_Err("No input file specified."); exit(1); } if (ver == -1) { /* guess at version */ if (strstr(fname,"2009")) { ver = 2009; SUMA_S_Notev("Guessed FS annot version of %d\n", ver); } else if (strstr(fname,"2005")) { ver = 2005; SUMA_S_Notev("Guessed FS annot version of %d\n", ver); } else { SUMA_S_Notev("Assuming FS annot version of %d\n", ver); } } if (hemi == 0) { if (strstr(fname,"lh.")) { hemi = -1; SUMA_S_Note("Guessed left hemisphere"); } else if (strstr(fname,"rh.")) { SUMA_S_Note("Guessed right hemisphere"); hemi = 1; } else { if (ver == 2009) { hemi = -1; SUMA_S_Note("Assuming left hemisphere.\n"); } else { /* leave it not set */ } } } if (ver == 2009 && !ctfile) { char *eee = getenv("FREESURFER_HOME"); if (!eee) { SUMA_S_Warn("Environment variable FREESURFER_HOME not set.\n" "Cannot locate FreeSurferColorLUT.txt\n"); } else { sprintf(sbuf, "%s/FreeSurferColorLUT.txt", eee); ctfile = sbuf; SUMA_S_Notev("Using %s\n", ctfile); } } if (lbl1 < 0 && lbl2 < 0) { /* need some setup */ if (ver == 2009) { if (hemi == -1) { lbl1 = 13100; lbl2 = 13199; SUMA_S_Notev("Setting -FScmaprange to [%d %d]\n", lbl1, lbl2); } else if (hemi == 1) { lbl1 = 14100; lbl2 = 14199; SUMA_S_Notev("Setting -FScmaprange to [%d %d]\n", lbl1, lbl2); } else { SUMA_S_Warn("-FScmaprange is not set.\n" "You may need to set it, check results.\n"); } } else if (ver == 2005 && FSdefault) { if (hemi == -1) { lbl1 = 3100; lbl2 = 3199; SUMA_S_Notev("Setting -FScmaprange to [%d %d]\n", lbl1, lbl2); } else if (hemi == 1) { lbl1 = 4100; lbl2 = 4199; SUMA_S_Notev("Setting -FScmaprange to [%d %d]\n", lbl1, lbl2); } else { SUMA_S_Warn("-FScmaprange is not set.\n" "You may need to set it, check results.\n"); } } } if (!fcmap && !froi && !fcol && !Showct && !fdset) { SUMA_SL_Err("Nothing to do.\n" "Use either -cmap_1D or \n" " -roi_1D or -col_1D or \n" " -show_FScmap options."); exit(1); } if (fdset) { int exists = 0; char *ooo=NULL; exists = SUMA_WriteDset_NameCheck_s (fdset, NULL, SUMA_ASCII_NIML, 0, &ooo); if (exists != 0 && !THD_ok_overwrite()) { SUMA_S_Errv("Output dataset %s exists.\n", ooo); SUMA_free(ooo); ooo=NULL; exit(1); } } if (froi) { if (SUMA_filexists(froi) && !THD_ok_overwrite()) { fprintf( SUMA_STDERR, "Error %s: File %s exists, will not overwrite.\n", FuncName, froi); SUMA_RETURN (NOPE); } } if (fcmap) { if (SUMA_filexists(fcmap) && !THD_ok_overwrite()) { fprintf( SUMA_STDERR, "Error %s: File %s exists, will not overwrite.\n", FuncName, fcmap); SUMA_RETURN (NOPE); } } if (fcol) { if (SUMA_filexists(fcol) && !THD_ok_overwrite()) { fprintf( SUMA_STDERR, "Error %s: File %s exists, will not overwrite.\n", FuncName, fcol); SUMA_RETURN (NOPE); } } if (!SUMA_readFSannot (fname, froi, fcmap, fcol, Showct, ctfile, lbl1, lbl2, &dset)) { SUMA_S_Err("Failed reading annotation file (or output file exists)"); exit(1); } if (!dset && fdset) { SUMA_S_Err("Have no dset to write"); exit(1); } if (fdset) { if (AFNI_yesenv("AFNI_NIML_TEXT_DATA")) { SUMA_WriteDset_eng(fdset, dset, SUMA_ASCII_NIML, 1, 1, 1); } else { SUMA_WriteDset_eng(fdset, dset, SUMA_BINARY_NIML, 1, 1, 1); } } if (testmode) { int key, indx, ism, suc; SUMA_COLOR_MAP *SM2=NULL, *SM=NULL; char *s=NULL, stmp[256]; SUMA_PARSED_NAME *sname=NULL; NI_group *ngr=NULL; SUMA_S_Note("Testing Chunk Begins"); /* check */ if (!SUMA_is_Label_dset(dset, &ngr)) { SUMA_S_Err("Dset is no label dset"); exit(1); } /* write it */ /* play with the colormap */ if (ngr) { if (!(SM = SUMA_NICmapToCmap(ngr))){ SUMA_S_Err("Failed to create SUMA colormap"); exit(1); } ngr = NULL; /* that's a copy of what was in dset, do not free it */ if (!SUMA_CreateCmapHash(SM)) { SUMA_S_Err("Failed to create hash"); exit(1); } /* Now pretend you are retrieving the index in cmap of some key */ for (ism=0; ism < SM->N_M[0]; ++ism) { /* the key is coming from SM, because I store all keys there But key normally comes from a certain node's value */ key = SM->idvec[ism]; indx = SUMA_ColMapKeyIndex(key, SM); if (indx < 0) { SUMA_S_Errv("Hashkey %d not found\n", key); } else { fprintf(SUMA_STDERR, "hashed id %d --> index %d\n" "known id %d --> index %d\n", key, indx, key, ism); } } /* Now try it with an unknown key */ key = -13; indx = SUMA_ColMapKeyIndex(key, SM); if (indx < 0) { fprintf(SUMA_STDERR, "id %d is not in the hash table, as expected\n", key); } else { SUMA_S_Errv("Should not have found %d\n", key); } SUMA_S_Note("Now Show it to me"); s = SUMA_ColorMapVec_Info (&SM, 1, 2); if (s) { fprintf(SUMA_STDERR,"%s", s); SUMA_free(s); s = NULL; } SUMA_S_Notev("Now turn it to niml (%s)\n", SM->Name); ngr = SUMA_CmapToNICmap(SM); sname = SUMA_ParseFname(SM->Name, NULL); snprintf(stmp, 128*sizeof(char), "file:%s.niml.cmap", sname->FileName_NoExt); NEL_WRITE_TX(ngr, stmp, suc); if (!suc) { SUMA_S_Errv("Failed to write %s\n", stmp); } SUMA_Free_Parsed_Name(sname); sname = NULL; SUMA_S_Note("Now turn niml colormap to SUMA's colormap"); SM2 = SUMA_NICmapToCmap(ngr); SUMA_S_Note("Now Show it to me2"); s = SUMA_ColorMapVec_Info (&SM2, 1, 2); if (s) { fprintf(SUMA_STDERR,"%s", s); SUMA_free(s); s = NULL; } NI_free_element(ngr); ngr=NULL; SUMA_Free_ColorMap(SM); SM = NULL; SUMA_Free_ColorMap(SM2); SM2 = NULL; } SUMA_S_Note("Testing Chunk End"); } if (dset) SUMA_FreeDset(dset); dset = NULL; exit(0); }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"SurfPatch"}; SUMA_GETPATCH_OPTIONS *Opt; char *ppref=NULL, ext[5]; float *far=NULL; MRI_IMAGE *im = NULL; int SO_read = -1; int *NodePatch=NULL, N_NodePatch=-1, *FaceSetList=NULL , N_FaceSet = -1, N_Node = -1, N_Spec=0; int i, inodeoff=-1, ilabeloff=-1, nvec, ncol, cnt; SUMA_SurfaceObject *SO = NULL; SUMA_PATCH *ptch = NULL; SUMA_SurfSpecFile *Spec; SUMA_INDEXING_ORDER d_order; void *SO_name = NULL; SUMA_Boolean exists = NOPE; SUMA_SO_File_Type typetmp; SUMA_SurfaceObject *SOnew = NULL; float *NodeList = NULL; SUMA_GENERIC_ARGV_PARSE *ps=NULL; SUMA_Boolean LocalHead = NOPE; SUMA_STANDALONE_INIT; SUMA_mainENTRY; ps = SUMA_Parse_IO_Args(argc, argv, "-i;-t;-spec;-s;-sv;"); /* Allocate space for DO structure */ SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS); Opt = SUMA_GetPatch_ParseInput (argv, argc, ps); if (argc < 2) { SUMA_S_Err("Too few options"); usage_SUMA_getPatch(ps, 0); exit (1); } /* read all surfaces */ Spec = SUMA_IO_args_2_spec(ps, &N_Spec); if (N_Spec == 0) { SUMA_S_Err("No surfaces found."); exit(1); } if (N_Spec > 1 ) { SUMA_S_Err( "Mike, you cannot mix -spec with -i or -t options " "for specifying surfaces."); exit(1); } if (Spec->N_Surfs < 1) { SUMA_S_Err("No surfaces"); exit(1); } if (Opt->DoVol && Spec->N_Surfs != 2) { SUMA_S_Errv("Must specify 2 and only 2 surfaces with -vol options\n" "Have %d from the command line\n",Spec->N_Surfs); exit(1); } if (Opt->oType != SUMA_FT_NOT_SPECIFIED && !Opt->VolOnly) { for (i=0; i < Spec->N_Surfs; ++i) { if (Spec->N_Surfs > 1) { sprintf(ext, "_%c", 65+i); ppref = SUMA_append_string(Opt->out_prefix, ext); } else { ppref = SUMA_copy_string(Opt->out_prefix); } SO_name = SUMA_Prefix2SurfaceName(ppref, NULL, NULL, Opt->oType, &exists); if (exists && !THD_ok_overwrite()) { fprintf(SUMA_STDERR, "Error %s:\nOutput file(s) %s* on disk.\n" "Will not overwrite.\n", FuncName, ppref); exit(1); } if (ppref) SUMA_free(ppref); ppref = NULL; if (SO_name) SUMA_free(SO_name); SO_name = NULL; } } /* read in the file containing the node information */ im = mri_read_1D (Opt->in_name); if (!im) { SUMA_S_Errv("Failed to read 1D file '%s'\n", Opt->in_name); exit(1); } far = MRI_FLOAT_PTR(im); nvec = im->nx; ncol = im->ny; if (Opt->nodecol >= ncol || Opt->labelcol >= ncol) { fprintf(SUMA_STDERR, "\n" "Error %s: Input file has a total of %d columns.\n" "One or both user-specified node (%d) and \n" "label (%d) columns are too high. Maximum usable\n" "column index is %d.\n" , FuncName, ncol, Opt->nodecol, Opt->labelcol, ncol -1 ); exit(1); } d_order = SUMA_COLUMN_MAJOR; if (!nvec) { SUMA_SL_Err("Empty file"); exit(1); } /* form the node vector */ NodePatch = (int *)SUMA_malloc(sizeof(int)*nvec); if (!NodePatch) { SUMA_SL_Crit("Failed to allocate."); exit(1); } inodeoff = Opt->nodecol*nvec; if (Opt->labelcol < 0) { /* all listed nodes */ for (i=0; i<nvec; ++i) { NodePatch[i] = far[i+inodeoff]; } N_NodePatch = nvec; } else { ilabeloff = Opt->labelcol*nvec; if (Opt->thislabel < 0) { /* all nodes with non zero labels */ cnt = 0; for (i=0; i<nvec; ++i) { if (far[i+ilabeloff]) { NodePatch[cnt] = far[i+inodeoff]; ++cnt; } } N_NodePatch = cnt; } else { /* select labels */ cnt = 0; for (i=0; i<nvec; ++i) { if (far[i+ilabeloff] == Opt->thislabel) { NodePatch[cnt] = far[i+inodeoff]; ++cnt; } } N_NodePatch = cnt; } NodePatch = (int *) SUMA_realloc(NodePatch , sizeof(int)*N_NodePatch); } /* done with im, free it */ mri_free(im); im = NULL; if (Opt->DoVol) { SUMA_SurfaceObject *SO1 = SUMA_Load_Spec_Surf_with_Metrics(Spec, 0, ps->sv[0], 0); SUMA_SurfaceObject *SO2 = SUMA_Load_Spec_Surf_with_Metrics(Spec, 1, ps->sv[0], 0); double Vol = 0.0; SUMA_SurfaceObject *SOp = SUMA_Alloc_SurfObject_Struct(1); byte *adj_N=NULL; if (Opt->adjust_contour) adj_N = SUMA_calloc(SO1->N_Node, sizeof(byte)); if (!SO1 || !SO2) { SUMA_SL_Err("Failed to load surfaces."); exit(1); } /* a chunk used to test SUMA_Pattie_Volume */ Vol = SUMA_Pattie_Volume(SO1, SO2, NodePatch, N_NodePatch, SOp, Opt->minhits, Opt->FixBowTie, Opt->adjust_contour, adj_N, Opt->verb); fprintf (SUMA_STDOUT,"Volume = %f\n", fabs(Vol)); if (Opt->out_volprefix) { if (Opt->oType != SUMA_FT_NOT_SPECIFIED) SOp->FileType = Opt->oType; if (Opt->flip) { if (Opt->verb > 1) SUMA_S_Note("Flipping stitched surf's triangles\n"); SUMA_FlipSOTriangles (SOp); } if (!(SUMA_Save_Surface_Object_Wrap ( Opt->out_volprefix, NULL, SOp, SUMA_PLY, SUMA_ASCII, NULL))) { fprintf (SUMA_STDERR, "Error %s: Failed to write surface object.\n", FuncName); } if (Opt->adjust_contour && adj_N) { Opt->out_volprefix = SUMA_append_replace_string(Opt->out_volprefix, ".adjneighb","",1); ppref = SUMA_Extension(Opt->out_volprefix, ".1D.dset", NOPE); SUMA_WRITE_IND_ARRAY_1D(adj_N, NULL, SO1->N_Node, 1, ppref); SUMA_free(ppref); ppref=NULL; } } if (SOp) SUMA_Free_Surface_Object(SOp); SOp = NULL; } if (!Opt->VolOnly) { FaceSetList = NULL; N_FaceSet = -1; for (i=0; i < Spec->N_Surfs; ++i) {/* loop to read in surfaces */ /* now identify surface needed */ if (!(SO = SUMA_Load_Spec_Surf_with_Metrics(Spec, i, ps->sv[0], 0))) { SUMA_S_Err("Failed to load surface .\n"); exit(1); } if (SO->aSO) { /* otherwise, when you reset the number of FaceSets for example, and you still write in GIFTI, the old contents of aSO will prevail */ SO->aSO = SUMA_FreeAfniSurfaceObject(SO->aSO); } /* extract the patch */ ptch = SUMA_getPatch (NodePatch, N_NodePatch, SO->N_Node, SO->FaceSetList, SO->N_FaceSet, SO->MF, Opt->minhits, Opt->FixBowTie, (!i && !Opt->DoVol)); /* verbose only for first patch, and if no volume computation was required This is to keep the warnings to a minimum*/ if (!ptch) { SUMA_SL_Err("Failed to form patch."); exit(1); } if (LocalHead) SUMA_ShowPatch(ptch, NULL); /* Now create a surface with that patch */ if (Spec->N_Surfs > 1) { sprintf(ext, "_%c", 65+i); ppref = SUMA_append_string(Opt->out_prefix, ext); } else { ppref = SUMA_copy_string(Opt->out_prefix); } /* save the original type */ typetmp = SO->FileType; if (Opt->oType != SUMA_FT_NOT_SPECIFIED) SO->FileType = Opt->oType; SO_name = SUMA_Prefix2SurfaceName(ppref, NULL, NULL, SO->FileType, &exists); if (ppref) SUMA_free(ppref); ppref = NULL; /* save the original pointers to the facesets and their number */ FaceSetList = SO->FaceSetList; N_FaceSet = SO->N_FaceSet; NodeList = SO->NodeList; N_Node = SO->N_Node; /* replace with Patch */ SO->FaceSetList = ptch->FaceSetList; SO->N_FaceSet = ptch->N_FaceSet; if (Opt->Do_p2s) { if (LocalHead) fprintf (SUMA_STDERR, "%s: Changing patch to surface...\n", FuncName); SOnew = SUMA_Patch2Surf(SO->NodeList, SO->N_Node, SO->FaceSetList, SO->N_FaceSet, 3); if (!SOnew) { SUMA_S_Err("Failed to change patch to surface."); exit(1); } SO->FaceSetList = SOnew->FaceSetList; SO->N_FaceSet = SOnew->N_FaceSet; SO->N_Node = SOnew->N_Node; SO->NodeList = SOnew->NodeList; } if (SO->N_FaceSet <= 0) { SUMA_S_Warn("The patch is empty.\n" " Non existing surface not written to disk.\n"); } else { /* Is the gain wanted? */ if (Opt->coordgain) { SUMA_SL_Note("Applying coord gain to surface nodes!"); for (cnt=0; cnt < SO->NodeDim*SO->N_Node; ++cnt) SO->NodeList[cnt] *= Opt->coordgain; } if (Opt->flip) { if (Opt->verb > 1) SUMA_S_Note("Flipping triangles\n"); SUMA_FlipTriangles (SO->FaceSetList, SO->N_FaceSet); SUMA_RECOMPUTE_NORMALS(SO); } if (!SUMA_Save_Surface_Object (SO_name, SO, SO->FileType, SUMA_ASCII, NULL)) { fprintf (SUMA_STDERR, "Error %s: Failed to write surface object.\n", FuncName); exit (1); } } /* bring SO back to shape */ SO->FileType = typetmp; SO->FaceSetList = FaceSetList; FaceSetList = NULL; SO->N_FaceSet = N_FaceSet; N_FaceSet = -1; SO->NodeList = NodeList; NodeList = NULL; SO->N_Node = N_Node; N_Node = -1; if (SO_name) SUMA_free(SO_name); SO_name = NULL; if (ptch) SUMA_freePatch(ptch); ptch = NULL; if (SOnew) SUMA_Free_Surface_Object(SOnew); SOnew = NULL; /* get rid of old surface object */ } } SUMA_LH("clean up"); if (!SUMA_FreeSpecFields(Spec)) { SUMA_S_Err("Failed to free spec fields"); } SUMA_free(Spec); Spec = NULL; if (Opt->out_prefix) SUMA_free(Opt->out_prefix); Opt->out_prefix = NULL; if (Opt->out_volprefix) SUMA_free(Opt->out_volprefix); Opt->out_volprefix = NULL; if (Opt) SUMA_free(Opt); if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) { SUMA_SL_Err("DO Cleanup Failed!"); } if (!SUMA_Free_CommonFields(SUMAg_CF)) { SUMA_SL_Err("SUMAg_CF Cleanup Failed!"); } SUMA_RETURN(0); }
/*! \brief parse the arguments for SurfSmooth program \param argv (char *) \param argc (int) \return Opt (SUMA_GETPATCH_OPTIONS *) options structure. To free it, use SUMA_free(Opt->out_prefix); SUMA_free(Opt); */ SUMA_GETPATCH_OPTIONS *SUMA_GetPatch_ParseInput (char *argv[], int argc, SUMA_GENERIC_ARGV_PARSE *ps) { static char FuncName[]={"SUMA_GetPatch_ParseInput"}; SUMA_GETPATCH_OPTIONS *Opt=NULL; int kar, i, ind; char *outprefix; SUMA_Boolean brk = NOPE; SUMA_Boolean LocalHead = NOPE; SUMA_ENTRY; Opt = (SUMA_GETPATCH_OPTIONS *)SUMA_malloc(sizeof(SUMA_GETPATCH_OPTIONS)); kar = 1; Opt->iType = SUMA_FT_NOT_SPECIFIED; Opt->out_prefix = NULL; Opt->out_volprefix = NULL; Opt->in_name = NULL; Opt->minhits = 2; Opt->labelcol = -1; Opt->nodecol = -1; Opt->thislabel = -1; Opt->DoVol = 0; Opt->VolOnly = 0; Opt->coordgain = 0.0; Opt->Do_p2s = NOPE; Opt->FixBowTie = -1; Opt->adjust_contour = -1; Opt->oType = SUMA_FT_NOT_SPECIFIED; Opt->verb = 1; Opt->flip = 0; brk = NOPE; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { usage_SUMA_getPatch(ps, strlen(argv[kar]) > 3 ? 2:1); exit (0); } SUMA_SKIP_COMMON_OPTIONS(brk, kar); if (!brk && (strcmp(argv[kar], "-hits") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -hits \n"); exit (1); } Opt->minhits = atoi(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-coord_gain") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -coord_gain \n"); exit (1); } Opt->coordgain = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-masklabel") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -masklabel \n"); exit (1); } Opt->thislabel = atoi(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-patch2surf") == 0)) { Opt->Do_p2s = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-vol") == 0)) { Opt->DoVol = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-flip_orientation") == 0)) { Opt->flip = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-vol_only") == 0)) { Opt->DoVol = 1; Opt->VolOnly = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-adjust_contour") == 0)) { Opt->adjust_contour = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-do-not-adjust_contour") == 0)) { Opt->adjust_contour = 0; brk = YUP; } if (!brk && (strcmp(argv[kar], "-check_bowtie") == 0)) { Opt->FixBowTie = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-fix_bowtie") == 0)) { Opt->FixBowTie = 2; brk = YUP; } if (!brk && (strcmp(argv[kar], "-ok_bowtie") == 0)) { Opt->FixBowTie = 0; brk = YUP; } if (!brk && (strcmp(argv[kar], "-prefix") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -prefix \n"); exit (1); } Opt->out_prefix = SUMA_copy_string(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-verb") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -verb \n"); exit (1); } Opt->verb = atoi(argv[kar]); if (Opt->verb < 0 || Opt->verb > 10) { SUMA_S_Errv("Something fishy with -verb value of %s\n" "Need integer from 0 to 2\n", argv[kar]); exit(1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-stiched_surface") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -stiched_surface \n"); exit (1); } Opt->out_volprefix = SUMA_copy_string(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-out_type") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -out_type \n"); exit (1); } Opt->oType = SUMA_guess_surftype_argv(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-input") == 0)) { kar ++; if (kar+2 >= argc) { fprintf (SUMA_STDERR, "need 3 arguments after -input \n"); exit (1); } Opt->in_name = argv[kar]; kar ++; Opt->nodecol = atoi(argv[kar]); kar ++; Opt->labelcol = atoi(argv[kar]); brk = YUP; } #if 0 if (!brk && (strcmp(argv[kar], "-spec") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -spec \n"); exit (1); } Opt->spec_file = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-sv") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -sv \n"); exit (1); } Opt->sv_name = argv[kar]; brk = YUP; } if (!brk && (strncmp(argv[kar], "-surf_", 6) == 0)) { if (kar + 1>= argc) { fprintf (SUMA_STDERR, "need argument after -surf_X SURF_NAME \n"); exit (1); } ind = argv[kar][6] - 'A'; if (ind < 0 || ind >= SURFPATCH_MAX_SURF) { fprintf (SUMA_STDERR, "-surf_X SURF_NAME option is out of range.\n"); exit (1); } kar ++; Opt->surf_names[ind] = argv[kar]; Opt->N_surf = ind+1; brk = YUP; } #endif if (!brk && !ps->arg_checked[kar]) { fprintf (SUMA_STDERR, "Error %s:\nOption %s not understood. Try -help for usage\n", FuncName, argv[kar]); suggest_best_prog_option(argv[0], argv[kar]); exit (1); } else { brk = NOPE; kar ++; } } /* sanity checks */ if (Opt->FixBowTie < 0) { if (Opt->DoVol) Opt->FixBowTie = 1; /* important to check in this case */ else Opt->FixBowTie = 0; } if (Opt->adjust_contour < 0) { if (Opt->DoVol) Opt->adjust_contour = 0; else Opt->adjust_contour = 0; } if (!Opt->out_prefix) Opt->out_prefix = SUMA_copy_string("SurfPatch"); if (Opt->thislabel >= 0 && Opt->labelcol < 0) { SUMA_SL_Err("Cannot use -masklabel without specifying " "ilabel in -input option"); exit(1); } if (Opt->minhits < 1 || Opt->minhits > 3) { SUMA_SL_Err("minhits must be > 0 and < 3"); exit(1); } if (!Opt->in_name) { SUMA_SL_Err("No input specified."); exit(1); } SUMA_RETURN (Opt); }
void SUMA_FindNgrNamedElementRec(NI_group *ngr, char *elname, void **nelp) { static char FuncName[]={"SUMA_FindNgrNamedElementRec"}; NI_element *nel = NULL; NI_group *nelg = NULL; char *rs=NULL; int ip; int LocalHead = 0; SUMA_ENTRY; if (!ngr || !elname) { SUMA_S_Err("NULL input "); SUMA_RETURNe; } /* now read the elements in this group */ for( ip=0 ; ip < ngr->part_num ; ip++ ){ switch( ngr->part_typ[ip] ){ /*-- a sub-group ==> recursion! --*/ case NI_GROUP_TYPE: nelg = (NI_group *)ngr->part[ip] ; if (LocalHead > 1) { fprintf( SUMA_STDERR, "%s: Looking for %s in group %s \n", FuncName, elname, ngr->name); } if (!strcmp(elname, nelg->name)) { *nelp=(void *)nelg; if (LocalHead) { fprintf( SUMA_STDERR, "%s: Found %s in group %s\n", FuncName, nelg->name, ngr->name); } SUMA_RETURNe; } SUMA_FindNgrNamedElementRec( (NI_group *)ngr->part[ip], elname, nelp); break ; case NI_ELEMENT_TYPE: nel = (NI_element *)ngr->part[ip] ; if (LocalHead > 1) { fprintf( SUMA_STDERR, "%s:>%d< Looking for %s name=%s \n" "vec_len=%d vec_filled=%d, vec_num=%d\n", FuncName, ip, elname, nel->name, nel->vec_len, nel->vec_filled, nel->vec_num ); } if (!strcmp(elname, nel->name)) { *nelp=(void *)nel; if (LocalHead) { fprintf( SUMA_STDERR, "%s: Found %s in group %s\n", FuncName, nel->name, ngr->name); } SUMA_RETURNe; } break; default: SUMA_SL_Err("Don't know what to make of this group element\n" "ignoring."); break; } } SUMA_RETURNe; }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"quickspec"}; int detail, kar, i, j, N_surf, N_name, idefstate; FILE *fid = NULL; char *spec_name, stmp[500], *Unique_st; SUMA_SO_File_Type TypeC[SUMA_MAX_N_SURFACE_SPEC]; static char *State[SUMA_MAX_N_SURFACE_SPEC], *Name_coord[SUMA_MAX_N_SURFACE_SPEC], *Name_topo[SUMA_MAX_N_SURFACE_SPEC], Anat[SUMA_MAX_N_SURFACE_SPEC], *LDP[SUMA_MAX_N_SURFACE_SPEC], *MARK[SUMA_MAX_N_SURFACE_SPEC], *LABEL[SUMA_MAX_N_SURFACE_SPEC]; SUMA_GENERIC_ARGV_PARSE *ps; SUMA_Boolean brk; SUMA_mainENTRY; /* allocate space for CommonFields structure */ SUMAg_CF = SUMA_Create_CommonFields (); if (SUMAg_CF == NULL) { fprintf( SUMA_STDERR, "Error %s: Failed in SUMA_Create_CommonFields\n", FuncName); exit(1); } ps = SUMA_Parse_IO_Args(argc, argv, "-t;"); if (argc < 3) { usage_SUMA_quickspec (ps); exit (1); } kar = 1; brk = NOPE; detail = 1; N_surf = 0; N_name = 0; spec_name = NULL; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { usage_SUMA_quickspec(ps); exit (1); } if (!brk && (strcmp(argv[kar], "-spec") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -spec \n"); exit (1); } spec_name = argv[kar]; if (!THD_ok_overwrite() && SUMA_filexists(spec_name)) { fprintf (SUMA_STDERR, "File %s exists, choose another one.\n", spec_name); exit(1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-tn") == 0)) { if (N_surf >= SUMA_MAX_N_SURFACE_SPEC) { SUMA_SL_Err("Exceeding maximum number of allowed surfaces..."); exit(1); } /* get the type */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "Type argument must follow -tn \n"); exit (1); } TypeC[N_surf] = SUMA_SurfaceTypeCode(argv[kar]); if (TypeC[N_surf] == SUMA_FT_ERROR || TypeC[N_surf] == SUMA_FT_NOT_SPECIFIED) { fprintf (SUMA_STDERR, "%s is a bad file type.\n", argv[kar]); exit(1); } /* get the name */ if (TypeC[N_surf] == SUMA_SUREFIT || TypeC[N_surf] == SUMA_VEC) N_name = 2; else N_name = 1; if (kar+N_name >= argc) { fprintf (SUMA_STDERR, "need %d elements for NAME \n", N_name); exit (1); } kar ++; Name_coord[N_surf] = argv[kar]; if (N_name == 2) { kar ++; Name_topo[N_surf] = argv[kar]; } else { Name_topo[N_surf] = NULL; } State[N_surf] = NULL; Anat[N_surf] = 'Y'; LDP[N_surf] = NULL; ++N_surf; brk = YUP; } if (!brk && (strcmp(argv[kar], "-tsn") == 0)) { if (N_surf >= SUMA_MAX_N_SURFACE_SPEC) { SUMA_SL_Err("Exceeding maximum number of allowed surfaces..."); exit(1); } /* get the type */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "TYPE argument must follow -tsn \n"); exit (1); } TypeC[N_surf] = SUMA_SurfaceTypeCode(argv[kar]); if ( TypeC[N_surf] == SUMA_FT_ERROR || TypeC[N_surf] == SUMA_FT_NOT_SPECIFIED) { fprintf (SUMA_STDERR, "%s is a bad file TYPE.\n", argv[kar]); exit(1); } /* get the state */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "STATE argument must follow TYPE with -tsn \n"); exit (1); } State[N_surf] = argv[kar]; /* get the name */ if ( TypeC[N_surf] == SUMA_SUREFIT || TypeC[N_surf] == SUMA_VEC) N_name = 2; else N_name = 1; if (kar+N_name >= argc) { fprintf (SUMA_STDERR, "need %d elements for NAME \n", N_name); exit (1); } kar ++; Name_coord[N_surf] = argv[kar]; if (N_name == 2) { kar ++; Name_topo[N_surf] = argv[kar]; } else { Name_topo[N_surf] = NULL; } Anat[N_surf] = 'Y'; LDP[N_surf] = NULL; ++N_surf; brk = YUP; } if (!brk && (strcmp(argv[kar], "-tsnad") == 0)) { if (N_surf >= SUMA_MAX_N_SURFACE_SPEC) { SUMA_SL_Err("Exceeding maximum number of allowed surfaces..."); exit(1); } /* get the type */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "TYPE argument must follow -tsnad \n"); exit (1); } TypeC[N_surf] = SUMA_SurfaceTypeCode(argv[kar]); if ( TypeC[N_surf] == SUMA_FT_ERROR || TypeC[N_surf] == SUMA_FT_NOT_SPECIFIED) { fprintf (SUMA_STDERR, "%s is a bad file TYPE.\n", argv[kar]); exit(1); } /* get the state */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "STATE argument must follow TYPE with -tsnad \n"); exit (1); } State[N_surf] = argv[kar]; /* get the name */ if ( TypeC[N_surf] == SUMA_SUREFIT || TypeC[N_surf] == SUMA_VEC) N_name = 2; else N_name = 1; if (kar+N_name >= argc) { fprintf (SUMA_STDERR, "need %d elements for NAME \n", N_name); exit (1); } kar ++; Name_coord[N_surf] = argv[kar]; if (N_name == 2) { kar ++; Name_topo[N_surf] = argv[kar]; } else { Name_topo[N_surf] = NULL; } /* get the anatomical flag */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "Anatomical flag must follow NAME with -tsnad \n"); exit (1); } Anat[N_surf] = SUMA_TO_UPPER_C(argv[kar][0]); if (Anat[N_surf] != 'Y' && Anat[N_surf] != 'N') { SUMA_S_Err("Anatomical flag must be either 'y' or 'n'"); exit (1); } /* get the LDP */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "LocalDomainParent must follow Anatomical flag with -tsnad \n"); exit (1); } LDP[N_surf] = argv[kar]; ++N_surf; brk = YUP; } if (!brk && (strcmp(argv[kar], "-tsnadm") == 0)) { if (N_surf >= SUMA_MAX_N_SURFACE_SPEC) { SUMA_SL_Err("Exceeding maximum number of allowed surfaces..."); exit(1); } /* get the type */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "TYPE argument must follow -tsnad \n"); exit (1); } TypeC[N_surf] = SUMA_SurfaceTypeCode(argv[kar]); if ( TypeC[N_surf] == SUMA_FT_ERROR || TypeC[N_surf] == SUMA_FT_NOT_SPECIFIED) { fprintf (SUMA_STDERR, "%s is a bad file TYPE.\n", argv[kar]); exit(1); } /* get the state */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "STATE argument must follow TYPE with -tsnad \n"); exit (1); } State[N_surf] = argv[kar]; /* get the name */ if ( TypeC[N_surf] == SUMA_SUREFIT || TypeC[N_surf] == SUMA_VEC) N_name = 2; else N_name = 1; if (kar+N_name >= argc) { fprintf (SUMA_STDERR, "need %d elements for NAME \n", N_name); exit (1); } kar ++; Name_coord[N_surf] = argv[kar]; if (N_name == 2) { kar ++; Name_topo[N_surf] = argv[kar]; } else { Name_topo[N_surf] = NULL; } /* get the anatomical flag */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "Anatomical flag must follow NAME with -tsnad \n"); exit (1); } Anat[N_surf] = SUMA_TO_UPPER_C(argv[kar][0]); if (Anat[N_surf] != 'Y' && Anat[N_surf] != 'N') { SUMA_S_Err("Anatomical flag must be either 'y' or 'n'"); exit (1); } /* get the LDP */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "LocalDomainParent must follow Anatomical flag with -tsnad \n"); exit (1); } LDP[N_surf] = argv[kar]; /* get the nodeMarker */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "LocalDomainParent must follow Anatomical flag with -tsnad \n"); exit (1); } MARK[N_surf] = argv[kar]; ++N_surf; brk = YUP; } if (!brk && (strcmp(argv[kar], "-tsnadl") == 0)) { if (N_surf >= SUMA_MAX_N_SURFACE_SPEC) { SUMA_SL_Err("Exceeding maximum number of allowed surfaces..."); exit(1); } /* get the type */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "TYPE argument must follow -tsnad \n"); exit (1); } TypeC[N_surf] = SUMA_SurfaceTypeCode(argv[kar]); if ( TypeC[N_surf] == SUMA_FT_ERROR || TypeC[N_surf] == SUMA_FT_NOT_SPECIFIED) { fprintf (SUMA_STDERR, "%s is a bad file TYPE.\n", argv[kar]); exit(1); } /* get the state */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "STATE argument must follow TYPE with -tsnad \n"); exit (1); } State[N_surf] = argv[kar]; /* get the name */ if ( TypeC[N_surf] == SUMA_SUREFIT || TypeC[N_surf] == SUMA_VEC) N_name = 2; else N_name = 1; if (kar+N_name >= argc) { fprintf (SUMA_STDERR, "need %d elements for NAME \n", N_name); exit (1); } kar ++; Name_coord[N_surf] = argv[kar]; if (N_name == 2) { kar ++; Name_topo[N_surf] = argv[kar]; } else { Name_topo[N_surf] = NULL; } /* get the anatomical flag */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "Anatomical flag must follow NAME with -tsnad \n"); exit (1); } Anat[N_surf] = SUMA_TO_UPPER_C(argv[kar][0]); if (Anat[N_surf] != 'Y' && Anat[N_surf] != 'N') { SUMA_S_Err("Anatomical flag must be either 'y' or 'n'"); exit (1); } /* get the LDP */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "LocalDomainParent must follow Anatomical flag with -tsnad \n"); exit (1); } LDP[N_surf] = argv[kar]; /* get the nodeMarker */ kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "LocalDomainParent must follow Anatomical flag with -tsnad \n"); exit (1); } LABEL[N_surf] = argv[kar]; ++N_surf; brk = YUP; } if (!brk) { fprintf (SUMA_STDERR, "Error %s: Option %s not understood. Try -help for usage\n", FuncName, argv[kar]); exit (1); } else { brk = NOPE; kar ++; } } /* write out the comments */ if (!spec_name) { fid = fopen("quick.spec", "w"); } else { fid = fopen(spec_name,"w"); } if (!fid){ SUMA_SL_Err("Failed to open file for output"); exit(1); } fprintf(fid,"# define the group\n"); fprintf(fid,"\tGroup = QuickSpec\n"); /* now create a list of unique states */ idefstate = 0; if (!State[0]) { Unique_st = SUMA_copy_string ("\tStateDef = S_1\n"); idefstate = 1; } else { sprintf(stmp, "\tStateDef = %s\n", State[0]); Unique_st = SUMA_copy_string (stmp); } for (i=1; i < N_surf; ++i) { if (!State[i]) { ++idefstate; sprintf(stmp,"\tStateDef = S_%d\n", idefstate); Unique_st = SUMA_append_replace_string (Unique_st, stmp, "", 1); } else { if (SUMA_iswordin(Unique_st, State[i]) != 1) { sprintf(stmp, "\tStateDef = %s\n", State[i]); Unique_st = SUMA_append_replace_string(Unique_st, stmp, "", 1); } } } fprintf (fid, "# define the various States\n"); fprintf (fid, "%s\n", Unique_st); /* check on LDP correctness */ for (i=0; i < N_surf; ++i) { if (LDP[i]) { if (!strcmp(LDP[i],"same") || !strcmp(LDP[i],"Same")) SUMA_TO_UPPER(LDP[i]); if (strcmp(LDP[i],"SAME")) { j= 0; while (j<N_surf && strcmp(LDP[i], Name_coord[j])) ++j; if (j == N_surf) { SUMA_S_Errv("Could not find a surface named %s\n" "to be the local domain parent of %s\n", LDP[i], Name_coord[i]); exit(1); } if (!strcmp(LDP[i], Name_coord[i])) {/* reset to SAME*/ LDP[i] = NULL; /* this results is SAME below */ } } } } /* now loop accross surfaces and write out the results */ idefstate = 0; for (i=0; i < N_surf; ++i) { fprintf(fid, "\nNewSurface\n"); fprintf(fid, "\tSurfaceType = %s\n", SUMA_SurfaceTypeString(TypeC[i])); if (!State[i]) { ++idefstate; fprintf(fid, "\tSurfaceState = S_%d\n", idefstate); } else fprintf(fid, "\tSurfaceState = %s\n", State[i]); if (Name_topo[i]) { fprintf(fid, "\tCoordFile = %s\n", Name_coord[i]); fprintf(fid, "\tTopoFile = %s\n", Name_topo[i]); } else { fprintf(fid, "\tSurfaceName = %s\n", Name_coord[i]); } /* add LocalDomainParent */ if (LDP[i]) fprintf(fid, "\tLocalDomainParent = %s\n", LDP[i]); else fprintf(fid, "\tLocalDomainParent = SAME\n"); /* add Anatomical */ if (Anat[i]) fprintf(fid, "\tAnatomical = %c\n", Anat[i]); else fprintf(fid, "\tAnatomical = Y\n"); /* add nodeMarker */ if (MARK[i]) fprintf(fid, "\tNodeMarker = %s\n", MARK[i]); if (LABEL[i]) fprintf(fid, "\tLabelDset = %s\n", LABEL[i]); /* binary ? */ switch (TypeC[i]) { case SUMA_FREE_SURFER: if (!SUMA_isExtension(Name_coord[i], ".asc")) { fprintf(fid, "\tSurfaceFormat = BINARY\n"); } break; default: break; } } fclose(fid); fid = NULL; if (Unique_st) SUMA_free(Unique_st); Unique_st = NULL; if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL; if (!SUMA_Free_CommonFields(SUMAg_CF)) { fprintf(SUMA_STDERR,"Error %s: SUMAg_CF Cleanup Failed!\n", FuncName); exit(1); } SUMA_RETURN(0); }/* main quickspec */
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"ConvexHull"}; int i, i3, nspec = 0; void *SO_name=NULL; SUMA_SurfaceObject *SO = NULL; SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt; char stmp[200]; SUMA_Boolean exists = NOPE; SUMA_Boolean LocalHead = NOPE; SUMA_GENERIC_ARGV_PARSE *ps=NULL; 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, "-o;-i;-sv;"); if (argc < 2) { usage_SUMA_ConvexHull(ps); exit (1); } Opt = SUMA_ConvexHull_ParseInput (argv, argc, ps); SO_name = SUMA_Prefix2SurfaceName(Opt->out_prefix, NULL, NULL, Opt->SurfFileType, &exists); if (exists && !THD_ok_overwrite()) { SUMA_S_Err("Output file(s) %s* on disk.\nWill not overwrite.\n", Opt->out_prefix); exit(1); } if (Opt->obj_type < 0) { if (Opt->in_name) { if (Opt->debug) { SUMA_S_Note("Creating mask..."); } if (!SUMA_Get_isosurface_datasets (Opt)) { SUMA_SL_Err("Failed to get data."); exit(1); } if (Opt->debug > 1) { if (Opt->debug == 2) { FILE *fout=fopen("inmaskvec.1D","w"); SUMA_S_Note("Writing masked values...\n"); if (!fout) { SUMA_SL_Err("Failed to write maskvec"); exit(1); } fprintf(fout, "#Col. 0 Voxel Index\n" "#Col. 1 Is a mask (all values here should be 1)\n" ); for (i=0; i<Opt->nvox; ++i) { if (Opt->mcdatav[i]) { fprintf(fout,"%d %.2f\n", i, Opt->mcdatav[i]); } } fclose(fout); fout = NULL; } else { FILE *fout=fopen("maskvec.1D","w"); SUMA_S_Note("Writing all mask values...\n"); if (!fout) { SUMA_S_Err("Failed to write maskvec"); exit(1); } fprintf(fout, "#Col. 0 Voxel Index\n" "#Col. 1 Is in mask ?\n" ); for (i=0; i<Opt->nvox; ++i) { fprintf(fout,"%d %.2f\n", i, Opt->mcdatav[i]); } fclose(fout); fout = NULL; } } } else if (Opt->in_1D) { MRI_IMAGE *im = NULL; float *far=NULL; int nx2; /* load the 1D file */ im = mri_read_1D (Opt->in_1D); if (!im) { SUMA_S_Err("Failed to read file"); exit(1); } far = MRI_FLOAT_PTR(im); if (im->nx == 0) { fprintf(SUMA_STDERR,"Error %s:\n Empty file %s.\n", FuncName, Opt->in_1D); exit(1); } if (im->ny != 3) { fprintf(SUMA_STDERR,"Error %s:\n Found %d columns in %s. Expecting 3\n", FuncName, im->ny, Opt->in_1D); exit(1); } /* copy the columns */ Opt->N_XYZ = im->nx; Opt->XYZ = (float *)SUMA_malloc(im->nx*im->ny*sizeof(float)); if (!Opt->XYZ) { SUMA_S_Crit("Failed to allocate."); exit(1); } nx2 = 2*im->nx; for (i=0;i<Opt->N_XYZ; ++i) { i3 = 3*i; Opt->XYZ[i3 ] = far[i]; Opt->XYZ[i3+1] = far[i+im->nx]; Opt->XYZ[i3+2] = far[i+nx2]; } /* done, clean up and out you go */ if (im) mri_free(im); im = NULL; } else if (ps->i_N_surfnames) { SUMA_SurfSpecFile *Spec=NULL; SUMA_SurfaceObject *SO=NULL; if (ps->i_N_surfnames > 1) { SUMA_S_Err("Only 1 input surface allowed!"); exit(1); } Spec = SUMA_IO_args_2_spec(ps, &nspec); if (!Spec) { SUMA_S_Err("Failed to create spec!"); exit(1); } if (nspec != 1) { SUMA_S_Warn("Expected one spec and nothing else"); } /* load the surface object */ SO = SUMA_Load_Spec_Surf(Spec, 0, ps->sv[0], 0); if (!SO) { SUMA_S_Err("Failed to read surface."); exit(1); } /* transfer coords */ if(SO->NodeDim != 3) { SUMA_S_Err("bad node coords."); exit(1); } Opt->N_XYZ = SO->N_Node; Opt->XYZ = (float *)SUMA_malloc(SO->N_Node * SO->NodeDim * sizeof(float)); if (!Opt->XYZ) { SUMA_S_Crit("Failed to allocate."); exit(1); } for (i=0;i<SO->NodeDim*SO->N_Node; ++i) Opt->XYZ[i] = SO->NodeList[i]; if (nspec) { int k=0; for (k=0; k<nspec; ++k) { if (!SUMA_FreeSpecFields(&(Spec[k]))) { SUMA_S_Err("Failed to free spec fields"); } } SUMA_free(Spec); Spec = NULL; nspec = 0; } if (SO) SUMA_Free_Surface_Object(SO); SO = NULL; } else { SUMA_S_Err("No input!"); exit(1); } } else { SUMA_S_Err("Bad input!"); exit(1); } /* Now call Marching Cube functions */ if (!(SO = SUMA_ConvexHullSurface(Opt))) { SUMA_S_Err("Failed to create surface.\n"); exit(1); } /* write the surface to disk */ if (!SUMA_Save_Surface_Object (SO_name, SO, Opt->SurfFileType, Opt->SurfFileFormat, NULL)) { fprintf (SUMA_STDERR, "Error %s: Failed to write surface object.\n", FuncName); exit (1); } if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL; if (Opt->fvec) SUMA_free(Opt->fvec); Opt->fvec = NULL; if (Opt->mcdatav) {SUMA_free(Opt->mcdatav); Opt->mcdatav = NULL;} if (Opt->in_vol) { DSET_delete( Opt->in_vol); Opt->in_vol = NULL;} if (Opt->out_prefix) SUMA_free(Opt->out_prefix); Opt->out_prefix = NULL; if (Opt->XYZ) SUMA_free(Opt->XYZ); Opt->XYZ = NULL; if (Opt) SUMA_free(Opt); if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) { SUMA_SL_Err("DO Cleanup Failed!"); } if (SO_name) SUMA_free(SO_name); SO_name = NULL; if (!SUMA_Free_CommonFields(SUMAg_CF)) SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1); exit(0); }
/*! contains code shamelessly stolen from Rick who stole it from Bob. */ SUMA_Boolean SUMA_Get_isosurface_datasets ( SUMA_GENERIC_PROG_OPTIONS_STRUCT * Opt) { static char FuncName[]={"SUMA_Get_isosurface_datasets"}; int i; SUMA_Boolean LocalHead = NOPE; SUMA_ENTRY; if (!Opt->in_vol && !Opt->in_name) { SUMA_S_Err("NULL input"); SUMA_RETURN(NOPE); } if (!Opt->in_vol) { /* open it */ Opt->in_vol = THD_open_dataset( Opt->in_name ); } if (!Opt->in_vol) { SUMA_S_Err("No volume could be had"); SUMA_RETURN(NOPE); } if (!ISVALID_DSET(Opt->in_vol)) { if (!Opt->in_name) { SUMA_SL_Err("NULL input volume."); SUMA_RETURN(NOPE); } else { SUMA_SL_Err("invalid volume."); SUMA_RETURN(NOPE); } } else if ( DSET_BRICK_TYPE(Opt->in_vol, 0) == MRI_complex) { SUMA_SL_Err("Can't do complex data."); SUMA_RETURN(NOPE); } Opt->nvox = DSET_NVOX( Opt->in_vol ); if (DSET_NVALS( Opt->in_vol) != 1) { SUMA_SL_Err("Input volume can only have one sub-brick in it.\n" "Use [.] selectors to choose sub-brick needed."); SUMA_RETURN(NOPE); } Opt->mcdatav = (double *)SUMA_malloc(sizeof(double)*Opt->nvox); if (!Opt->mcdatav) { SUMA_SL_Crit("Failed to allocate for maskv"); SUMA_RETURN(NOPE); } if (Opt->xform == SUMA_ISO_XFORM_MASK) { SUMA_LH("SUMA_ISO_XFORM_MASK"); switch (Opt->MaskMode) { case SUMA_ISO_CMASK: SUMA_LH("SUMA_ISO_CMASK"); if (Opt->cmask) { /* here's the second order grand theft */ int clen = strlen( Opt->cmask ); char * cmd; byte *bmask; cmd = (char *)malloc((clen + 1) * sizeof(char)); strcpy( cmd, Opt->cmask); bmask = EDT_calcmask( cmd, &Opt->ninmask, 0 ); SUMA_LHv("Have %d\n", Opt->ninmask); free( cmd ); /* free EDT_calcmask() string */ if ( bmask == NULL ) { SUMA_SL_Err("Failed to compute mask from -cmask option"); SUMA_free(Opt->mcdatav); Opt->mcdatav=NULL; SUMA_RETURN(NOPE); } if ( Opt->ninmask != Opt->nvox ) { SUMA_SL_Err("Input and cmask datasets do not have " "the same dimensions\n" ); SUMA_free(Opt->mcdatav); Opt->mcdatav=NULL; SUMA_RETURN(NOPE); } Opt->ninmask = THD_countmask( Opt->ninmask, bmask ); SUMA_LHv("Have %d\n", Opt->ninmask); for (i=0; i<Opt->nvox; ++i) if (bmask[i]) Opt->mcdatav[i] = (double)bmask[i]; else Opt->mcdatav[i] = -1; free(bmask);bmask=NULL; } else { SUMA_SL_Err("NULL cmask"); SUMA_RETURN(NOPE); } break; case SUMA_ISO_VAL: case SUMA_ISO_RANGE: SUMA_LH("SUMA_ISO_VAL, SUMA_ISO_RANGE"); /* load the dset */ DSET_load(Opt->in_vol); Opt->dvec = (double *)SUMA_malloc(sizeof(double) * Opt->nvox); if (!Opt->dvec) { SUMA_SL_Crit("Faile to allocate for dvec.\nOh misery."); SUMA_RETURN(NOPE); } EDIT_coerce_scale_type( Opt->nvox , DSET_BRICK_FACTOR(Opt->in_vol,0) , DSET_BRICK_TYPE(Opt->in_vol,0), DSET_ARRAY(Opt->in_vol, 0) , MRI_double , Opt->dvec ) ; /* no need for data in input volume anymore */ PURGE_DSET(Opt->in_vol); Opt->ninmask = 0; if (Opt->MaskMode == SUMA_ISO_VAL) { for (i=0; i<Opt->nvox; ++i) { if (Opt->dvec[i] == Opt->v0) { Opt->mcdatav[i] = 1; ++ Opt->ninmask; } else Opt->mcdatav[i] = -1; } } else if (Opt->MaskMode == SUMA_ISO_RANGE) { for (i=0; i<Opt->nvox; ++i) { if (Opt->dvec[i] >= Opt->v0 && Opt->dvec[i] < Opt->v1) { Opt->mcdatav[i] = 1; ++ Opt->ninmask; } else Opt->mcdatav[i] = -1; } } else { SUMA_SL_Err("Bad Miracle."); SUMA_RETURN(NOPE); } SUMA_free(Opt->dvec); Opt->dvec = NULL; /* this vector is not even created in SUMA_ISO_CMASK mode ...*/ break; default: SUMA_SL_Err("Unexpected value of MaskMode"); SUMA_RETURN(NOPE); break; } } else if (Opt->xform == SUMA_ISO_XFORM_SHIFT) { /* load the dset */ DSET_load(Opt->in_vol); Opt->dvec = (double *)SUMA_malloc(sizeof(double) * Opt->nvox); if (!Opt->dvec) { SUMA_SL_Crit("Failed to allocate for dvec.\nOh misery."); SUMA_RETURN(NOPE); } EDIT_coerce_scale_type( Opt->nvox , DSET_BRICK_FACTOR(Opt->in_vol,0) , DSET_BRICK_TYPE(Opt->in_vol,0), DSET_ARRAY(Opt->in_vol, 0) , MRI_double , Opt->dvec ) ; /* no need for data in input volume anymore */ PURGE_DSET(Opt->in_vol); Opt->ninmask = Opt->nvox; for (i=0; i<Opt->nvox; ++i) { Opt->mcdatav[i] = Opt->dvec[i] - Opt->v0; } SUMA_free(Opt->dvec); Opt->dvec = NULL; } else if (Opt->xform == SUMA_ISO_XFORM_NONE) { /* load the dset */ DSET_load(Opt->in_vol); Opt->dvec = (double *)SUMA_malloc(sizeof(double) * Opt->nvox); if (!Opt->dvec) { SUMA_SL_Crit("Faile to allocate for dvec.\nOh misery."); SUMA_RETURN(NOPE); } EDIT_coerce_scale_type( Opt->nvox , DSET_BRICK_FACTOR(Opt->in_vol,0) , DSET_BRICK_TYPE(Opt->in_vol,0), DSET_ARRAY(Opt->in_vol, 0) , MRI_double , Opt->dvec ) ; /* no need for data in input volume anymore */ PURGE_DSET(Opt->in_vol); Opt->ninmask = Opt->nvox; for (i=0; i<Opt->nvox; ++i) { Opt->mcdatav[i] = Opt->dvec[i]; } SUMA_free(Opt->dvec); Opt->dvec = NULL; } else { SUMA_SL_Err("Bad Opt->xform."); SUMA_RETURN(NOPE); } if ( Opt->ninmask <= 0 ) { if (Opt->ninmask == 0) { SUMA_SL_Err("A negative value!\nNothing to do." ); } else { SUMA_SL_Err("An empty mask!\n Nothing to do." ); } SUMA_RETURN(NOPE); } if (Opt->debug > 0) { fprintf( SUMA_STDERR, "%s:\nInput dset %s has nvox = %d, nvals = %d", FuncName, SUMA_CHECK_NULL_STR(Opt->in_name), Opt->nvox, DSET_NVALS(Opt->in_vol) ); fprintf( SUMA_STDERR, " (%d voxels in mask)\n", Opt->ninmask ); } SUMA_RETURN(YUP); }
/*! A less obtuse way to call IsoSurface extraction functions See SUMA_IsoSurface.c the types of values that should be passed if v0 == v1 --> isovalue of v0 extraction if v1 > v0 --> isorange of [v0;v1[ is used if v1 < v0 --> turn volume to mask (!=0) and set isovalue to 1 */ SUMA_SurfaceObject *SUMA_THD_IsoSurface(THD_3dim_dataset *in_volu, float v0, float v1, int debug) { static char FuncName[]={"SUMA_THD_IsoSurface"}; SUMA_SurfaceObject *SO= NULL; THD_3dim_dataset *in_vol=in_volu; SUMA_ISO_OPTIONS MaskMode=SUMA_ISO_UNDEFINED; SUMA_ISO_XFORMS xform=SUMA_ISO_XFORM_MASK; float *fv=NULL; int ii=0, n_mask=0; SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt=NULL; SUMA_Boolean LocalHead = NOPE; SUMA_ENTRY; if (v0 == v1) MaskMode = SUMA_ISO_VAL; else if (v1 > v0) MaskMode = SUMA_ISO_RANGE; else if (v1 < v0) {/* make a mask*/ MaskMode = SUMA_ISO_VAL; in_vol = EDIT_full_copy(in_volu,FuncName); EDIT_floatize_dataset(in_vol); fv = (float *)DSET_BRICK_ARRAY(in_vol,0); n_mask=0; for (ii=0; ii<DSET_NVOX(in_vol); ++ii) { if (fv[ii]) { fv[ii] = 1.0f; ++n_mask; } else { fv[ii] = 0.0f; } } v0 = 1.0; v1 = 0.0; } else { SUMA_S_Err("Could not determine maskmode"); SUMA_RETURN(SO); } Opt = (SUMA_GENERIC_PROG_OPTIONS_STRUCT *) SUMA_calloc(1,sizeof(SUMA_GENERIC_PROG_OPTIONS_STRUCT)); Opt->in_vol = in_vol; Opt->xform = xform; Opt->MaskMode = MaskMode; Opt->debug = debug; Opt->v0 = v0; Opt->v1 = v1; Opt->obj_type = -1; /* A la SUMA_IsoSurface.c */ if (!SUMA_Get_isosurface_datasets (Opt)) { SUMA_SL_Err("Failed to get data."); SUMA_RETURN(SO); } /* Now call Marching Cube functions */ if (!(SO = SUMA_MarchingCubesSurface(Opt))) { SUMA_S_Err("Failed to create surface.\n"); SUMA_RETURN(SO); } Opt->in_vol = NULL; /* Not yours to kill */ Opt->cmask = NULL; Opt = SUMA_Free_Generic_Prog_Options_Struct(Opt); if (in_vol && in_vol != in_volu) DSET_delete(in_vol); SUMA_RETURN(SO); }
/*! \brief parse the arguments for SurfQual program \param argv (char *) \param argc (int) \return Opt (SUMA_SURFQUAL_OPTIONS *) options structure. To free it, use SUMA_free(Opt->out_prefix); SUMA_free(Opt); */ SUMA_SURFQUAL_OPTIONS *SUMA_SurfQual_ParseInput (char *argv[], int argc, SUMA_GENERIC_ARGV_PARSE *ps) { static char FuncName[]= {"SUMA_SurfQual_ParseInput"}; SUMA_SURFQUAL_OPTIONS *Opt=NULL; int kar, i, ind; char *outprefix; SUMA_Boolean brk = NOPE; SUMA_Boolean LocalHead = NOPE; SUMA_ENTRY; Opt = (SUMA_SURFQUAL_OPTIONS *)SUMA_malloc(sizeof(SUMA_SURFQUAL_OPTIONS)); kar = 1; Opt->out_prefix = NULL; Opt->surftype = NULL; Opt->self_intersect = 0; Opt->DoSum = 0; brk = NOPE; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { usage_SUMA_SurfQual(ps, strlen(argv[kar]) > 3 ? 2:1); exit (0); } /* skip the options parsed in SUMA_ParseInput_basics_s */ SUMA_SKIP_COMMON_OPTIONS(brk, kar); if (!brk && (strcmp(argv[kar], "-sphere") == 0)) { if (Opt->surftype) { SUMA_S_Err( "Surface type already specified.\n" "Only one type allowed."); exit(1); } Opt->surftype = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-self_intersect") == 0)) { Opt->self_intersect = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-summary") == 0)) { Opt->DoSum = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-prefix") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -prefix \n"); exit (1); } Opt->out_prefix = SUMA_copy_string(argv[kar]); brk = YUP; } if (!brk && !ps->arg_checked[kar]) { fprintf (SUMA_STDERR, "Error %s:\nOption %s not understood. Try -help for usage\n", FuncName, argv[kar]); suggest_best_prog_option(argv[0], argv[kar]); exit (1); } else { brk = NOPE; kar ++; } } #if 0 if (Spec->N_Surfs < 1) { SUMA_SL_Err("No surface specified."); exit(1); } #endif SUMA_RETURN (Opt); }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"ScaleToMap"}; char *IntName = NULL, *Prfx, h[9], *CmapFileName = NULL, *dbfile = NULL, *MapName=NULL; MRI_IMAGE *im = NULL; float *far=NULL; int N_V, N_Int, kar, k, ii, i, icol=-1, vcol=-1, Sgn, interpmode, k3; int Vminloc, Vmaxloc, *iV = NULL; float Vmin, Vmax, brfact; float *V = NULL, *Vsort = NULL; float IntRange[2], MaskColor[3], MaskRange[2]={0.0, 0.0}, arange; SUMA_Boolean ApplyClip, ApplyMask, setMaskCol, ApplyPercClip, Vopt; SUMA_Boolean iVopt, inopt, NoMaskCol, MapSpecified, alaAFNI, MaskZero; SUMA_Boolean brk, frf, ShowMap, ShowMapdb; SUMA_COLOR_MAP *CM; SUMA_SCALE_TO_MAP_OPT * OptScl; int MapType, freecm = 1; SUMA_COLOR_SCALED_VECT * SV; SUMA_AFNI_COLORS *SAC=NULL; SUMA_Boolean FromAFNI = NOPE; int imap, isPmap, isNmap; SUMA_Boolean LocalHead = NOPE; SUMA_STANDALONE_INIT; SUMAg_CF->isGraphical = YUP; SUMA_mainENTRY; /* this is placed down here to */ /* if (argc < 3) { SUMA_ScaleToMap_usage(); exit (1); } */ kar = 1; brfact = 1; /* the brightness factor */ MaskColor[0] = MaskColor[1] = MaskColor[2] = 0.3; ApplyClip = NOPE; ApplyPercClip = NOPE; ApplyMask = NOPE; NoMaskCol = NOPE; MaskZero = NOPE; setMaskCol = NOPE; Vopt = NOPE; iVopt = NOPE; inopt = NOPE; MapType = SUMA_CMAP_RGYBR20; brk = NOPE; MapSpecified = NOPE; CmapFileName = NULL; interpmode = SUMA_UNDEFINED_MODE; ShowMap = NOPE; alaAFNI = NOPE; /* applying the alaAFNI mapping */ frf = NOPE; arange = -1.0; /* afni range specified */ Sgn = 0; ShowMapdb = NOPE; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { SUMA_ScaleToMap_usage(); exit (1); } SUMA_SKIP_COMMON_OPTIONS(brk, kar); if (!brk && strcmp(argv[kar], "-verb") == 0) { LocalHead = NOPE; brk = YUP; } if (!brk && strcmp(argv[kar], "-ionot") == 0) { SUMA_SL_Err("-ionot is obsolete. \n" "Use -trace option."); exit (1); SUMA_INOUT_NOTIFY_ON; brk = YUP; } if (!brk && strcmp(argv[kar], "-msk_zero") == 0) { MaskZero = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-input") == 0)) { kar ++; if (kar+2 >= argc) { fprintf (SUMA_STDERR, "need 3 arguments after -input \n"); exit (1); } IntName = argv[kar]; kar ++; icol = atoi(argv[kar]); kar ++; vcol = atoi(argv[kar]); inopt = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-apr") == 0)) { if (arange >= 0) { fprintf (SUMA_STDERR, "range has already been specified.\n"); exit (1); } kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -apr \n"); exit (1); } arange = atof(argv[kar]); if (arange < 0) { fprintf (SUMA_STDERR, "range must be positive.\n"); exit (1); } Sgn = 1; alaAFNI = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-anr") == 0)) { if (arange >= 0) { fprintf (SUMA_STDERR, "range has already been specified.\n"); exit (1); } kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -anr \n"); exit (1); } arange = atof(argv[kar]); if (arange < 0) { fprintf (SUMA_STDERR, "range must be positive.\n"); exit (1); } Sgn = -1; alaAFNI = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-v") == 0)) { fprintf (SUMA_STDERR, "\n -v option is now obsolete.\nUse -input option instead.\n"); exit (1); kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -v \n"); exit (1); } IntName = argv[kar]; Vopt = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-iv") == 0)) { fprintf (SUMA_STDERR, "\n -iv option is now obsolete.\nUse -input option instead.\n"); exit (1); kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -iv \n"); exit (1); } IntName = argv[kar]; iVopt = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-br") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -br \n"); exit (1); } brfact = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-frf") == 0)) { frf = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-showmap") == 0)) { ShowMap = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-showdb") == 0)) { ShowMapdb = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-nointerp") == 0)) { if (interpmode != SUMA_UNDEFINED_MODE) { fprintf (SUMA_STDERR, "Color interpolation mode already set.\n"); } interpmode = SUMA_NO_INTERP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-direct") == 0)) { if (interpmode != SUMA_UNDEFINED_MODE) { fprintf (SUMA_STDERR, "Color interpolation mode already set.\n"); } interpmode = SUMA_DIRECT; brk = YUP; } if (!brk && (strcmp(argv[kar], "-interp") == 0)) { if (interpmode != SUMA_UNDEFINED_MODE) { fprintf (SUMA_STDERR, "Color interpolation mode already set.\n(-nointerp, -direct and -interp are mutually exclusive.\n"); } interpmode = SUMA_INTERP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-clp") == 0)) { kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need 2 arguments after -clp \n"); exit (1); } ApplyClip = YUP; IntRange[0] = atof(argv[kar]); kar ++; IntRange[1] = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-perc_clp") == 0)) { kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need 2 arguments after -perc_clp "); exit (1); } ApplyPercClip = YUP; IntRange[0] = atof(argv[kar]); kar ++; IntRange[1] = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-msk") == 0)) { kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need 2 arguments after -msk "); exit (1); } ApplyMask = YUP; MaskRange[0] = atof(argv[kar]); kar ++; MaskRange[1] = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-nomsk_col") == 0)) { NoMaskCol = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-msk_col") == 0)) { kar ++; if (kar+2 >= argc) { fprintf (SUMA_STDERR, "need 3 arguments after -msk_col "); exit (1); } setMaskCol = YUP; MaskColor[0] = atof(argv[kar]); kar ++; MaskColor[1] = atof(argv[kar]); kar ++; MaskColor[2] = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-cmapfile") ==0)) { if (MapSpecified) { fprintf (SUMA_STDERR, "Color map already specified.\n-cmap and -cmapfile are mutually exclusive\n"); exit (1); } MapSpecified = YUP; kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 arguments after -cmapfile "); exit (1); } CmapFileName = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-cmapdb") ==0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 arguments after -cmapdb "); exit (1); } dbfile = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-cmap") ==0)) { if (MapSpecified) { fprintf (SUMA_STDERR, "Color map already specified.\n-cmap and -cmapfile are mutually exclusive\n"); exit (1); } MapSpecified = YUP; kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 arguments after -cmap "); exit (1); } MapName = argv[kar]; brk = YUP; } if (!brk) { fprintf (SUMA_STDERR,"Error %s: Option %s not understood. Try -help for usage\n", FuncName, argv[kar]); exit (1); } else { brk = NOPE; kar ++; } }/* loop accross command ine options */ /* Get your colors straightened out */ if (!SUMAg_CF->scm) { SUMAg_CF->scm = SUMA_Build_Color_maps(); if (!SUMAg_CF->scm) { SUMA_SL_Err("Failed to build color maps.\n"); exit(1); } } SAC = SUMAg_CF->scm; /* are there database files to read */ if (dbfile) { SUMA_LH("Now trying to read db file"); if (SUMA_AFNI_Extract_Colors ( dbfile, SAC ) < 0) { SUMA_S_Errv("Failed to read %s colormap file.\n", dbfile); exit(1); } } FromAFNI = NOPE; /* assume colormap is not coming from SAC (the colormap database structure) */ if (CmapFileName) { /* load the color map */ CM = SUMA_Read_Color_Map_1D (CmapFileName); if (CM == NULL) { SUMA_S_Err("Could not load colormap.\n"); exit (1); } if (frf) { SUMA_LH("Flipping colormap"); SUMA_Flip_Color_Map (CM); } if (!CM->Sgn) CM->Sgn = Sgn; }else{ /* dunno what kind of map yet. Try default first */ if (MapName) { CM = SUMA_FindNamedColMap (MapName); freecm = 0; if (CM) { /* good, sign it and out you go */ CM->Sgn = Sgn; } else { SUMA_S_Err("Could not get standard colormap.\n"); exit (1); } } else { SUMA_LH("An AFNI color map "); /* a color from AFNI's maps */ FromAFNI = YUP; imap = SUMA_Find_ColorMap ( MapName, SAC->CMv, SAC->N_maps, -2); if (imap < 0) { SUMA_S_Errv("Could not find colormap %s.\n", MapName); exit (1); } CM = SAC->CMv[imap]; } } /* show the colromap on STDERR */ if (ShowMap) { fprintf (SUMA_STDERR, "%s: Colormap used:\n", FuncName); SUMA_Show_ColorMapVec (&CM, 1, NULL, 2); { SUMA_SurfaceObject *SO = NULL; float orig[3] = { SUMA_CMAP_ORIGIN }; float topright[3] = { SUMA_CMAP_TOPLEFT }; SO = SUMA_Cmap_To_SO (CM, orig, topright, 2); if (SO) SUMA_Free_Surface_Object(SO); } exit(0); } /* show all the colors and colormaps in SAC on STDERR */ if (ShowMapdb) { fprintf (SUMA_STDERR, "%s: AFNI colormaps found in db:\n", FuncName); SUMA_Show_ColorVec (SAC->Cv, SAC->N_cols, NULL); SUMA_Show_ColorMapVec (SAC->CMv, SAC->N_maps, NULL, 2); exit(0); } if (!IntName) { fprintf (SUMA_STDERR,"Error %s: No input file specified.\n", FuncName); exit(1); } /* default interpolation mode */ if (interpmode == SUMA_UNDEFINED_MODE) interpmode = SUMA_INTERP; /* check input */ if (!SUMA_filexists (IntName)) { fprintf (SUMA_STDERR,"Error %s: File %s could not be found.\n", FuncName, IntName); exit(1); } if (frf && !CmapFileName) { fprintf (SUMA_STDERR,"Error %s: -frf option is only valid with -cmapfile.\n", FuncName); exit(1); } if (ApplyPercClip && ApplyClip) { fprintf (SUMA_STDERR,"Error %s: Simultaneous use of -clp and -perc_clp. You should be punished.\n", FuncName); exit(1); } if ((ApplyPercClip || ApplyClip) && arange >= 0.0) { fprintf (SUMA_STDERR,"Error %s: Simultaneous use of -clp/-perc_clp and -apr/anr.\n Read the help.\n", FuncName); exit(1); } if (iVopt || Vopt) { fprintf (SUMA_STDERR,"Error %s: -v and -iv are obsolete.\n Use -input option instead.\n", FuncName); exit(1); } if (!inopt) { fprintf (SUMA_STDERR,"Error %s: -input option must be specified.\n", FuncName); exit(1); } im = mri_read_1D (IntName); if (!im) { SUMA_S_Err("Failed to read file"); exit (1); } if (vcol < 0) { fprintf (SUMA_STDERR,"Error %s: vcol must be > 0\n", FuncName); exit(1); } far = MRI_FLOAT_PTR(im); if (icol < 0 && icol != -1) { fprintf (SUMA_STDERR,"Error %s: icol(%d) can only have -1 for a negative value\n", FuncName, icol); exit(1); } if (icol >= im->ny || vcol >= im->ny) { fprintf (SUMA_STDERR,"Error %s: icol(%d) and vcol(%d) must be < %d\nwhich is the number of columns in %s\n", FuncName, icol, vcol, im->ny, IntName); exit(1); } if (brfact <=0 || brfact > 1) { fprintf (SUMA_STDERR,"Error %s: BrightFact must be > 0 and <= 1.\n", FuncName); exit (1); } if (MaskColor[0] < 0 || MaskColor[0] > 1 || MaskColor[1] < 0 || MaskColor[1] > 1 || MaskColor[2] < 0 || MaskColor[2] > 1) { fprintf (SUMA_STDERR,"Error %s: MaskColor values must be >=0 <=1.\n", FuncName); exit(1); } N_V = im->nx; V = (float *) SUMA_calloc (N_V, sizeof(float)); iV = (int *) SUMA_calloc (N_V, sizeof(int)); if (!V || !iV) { fprintf (SUMA_STDERR,"Error %s: Could not allocate for V or iV.\n", FuncName); exit(1); } if (icol < 0) { for (ii=0; ii < N_V; ++ii) { iV[ii] = ii; V[ii] = far[vcol*N_V+ii]; } } else { for (ii=0; ii < N_V; ++ii) { iV[ii] = (int)far[icol*N_V+ii]; V[ii] = far[vcol*N_V+ii]; } } mri_free(im); im = NULL; /* read values per node */ /* SUMA_disp_vect (V, 3); */ /* find the min/max of V */ SUMA_MIN_MAX_VEC(V, N_V, Vmin, Vmax, Vminloc, Vmaxloc) /* fprintf (SUMA_STDERR,"%s: Vmin=%f, Vmax = %f\n", FuncName, Vmin, Vmax);*/ if (arange == 0.0) { if (fabs((double)Vmin) > fabs((double)Vmax)) arange = (float)fabs((double)Vmin); else arange = (float)fabs((double)Vmax); } /* figure out the range if PercRange is used */ if (ApplyPercClip) { fprintf (SUMA_STDERR,"%s: Percentile range [%f..%f] is equivalent to ", FuncName, IntRange[0], IntRange[1]); Vsort = SUMA_PercRange (V, NULL, N_V, IntRange, IntRange, NULL); fprintf (SUMA_STDERR,"[%f..%f]\n", IntRange[0], IntRange[1]); ApplyClip = YUP; if (Vsort) SUMA_free(Vsort); else { fprintf (SUMA_STDERR,"Error %s: Error in SUMA_PercRange.\n", FuncName); exit(1); } } /* get the options for creating the scaled color mapping */ OptScl = SUMA_ScaleToMapOptInit(); if (!OptScl) { fprintf (SUMA_STDERR, "Error %s: Could not get scaling option structure.\n", FuncName); exit (1); } /* work the options a bit */ if (ApplyMask) { OptScl->ApplyMask = ApplyMask; OptScl->MaskRange[0] = MaskRange[0]; OptScl->MaskRange[1] = MaskRange[1]; OptScl->MaskColor[0] = MaskColor[0]; OptScl->MaskColor[1] = MaskColor[1]; OptScl->MaskColor[2] = MaskColor[2]; } if (ApplyClip) { OptScl->ApplyClip = YUP; OptScl->IntRange[0] = IntRange[0]; OptScl->IntRange[1] = IntRange[1]; } OptScl->interpmode = interpmode; OptScl->BrightFact = brfact; if (MaskZero) OptScl->MaskZero = YUP; /* map the values in V to the colormap */ /* allocate space for the result */ SV = SUMA_Create_ColorScaledVect(N_V, 0); if (!SV) { fprintf (SUMA_STDERR, "Error %s: Could not allocate for SV.\n", FuncName); exit(1); } /* finally ! */ if (alaAFNI) { if (LocalHead) { fprintf (SUMA_STDERR, "%s: Calling SUMA_ScaleToMap_alaAFNI\n", FuncName); fprintf (SUMA_STDERR,"%s: arange = %f\n", FuncName, arange); } if (CM->frac) { if (CM->frac[0] > 0 && CM->Sgn == -1) { SUMA_S_Err ("Color map fractions positive with -anr option"); exit(1); } if (CM->frac[0] < 0 && CM->Sgn == 1) { SUMA_S_Err ("Color map fractions negative with -apr option"); exit(1); } } if (Sgn) { if (Sgn != CM->Sgn) { SUMA_S_Warn ("Mixing positive maps (all fractions > 0) " "with -anr option\n" "or vice versa. That is allowed but know what" " you're doing.\n"); } } if (!SUMA_ScaleToMap_alaAFNI (V, N_V, arange, CM, OptScl, SV)) { fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_ScaleToMap_alaAFNI.\n", FuncName); exit(1); } } else { if (LocalHead) fprintf (SUMA_STDERR,"%s: Calling SUMA_ScaleToMap\n", FuncName); if (!SUMA_ScaleToMap (V, N_V, Vmin, Vmax, CM, OptScl, SV)) { fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_ScaleToMap.\n", FuncName); exit(1); } } /* Now write the colored vector back to disk */ if (NoMaskCol) { for (k=0; k < N_V; ++k) { k3 = 3*k; if (!SV->isMasked[k]) fprintf (SUMA_STDOUT, "%d %f %f %f\n", iV[k], SV->cV[k3 ], SV->cV[k3+1], SV->cV[k3+2]); } } else { for (k=0; k < N_V; ++k) { k3 = 3*k; fprintf (SUMA_STDOUT, "%d %f %f %f\n", iV[k], SV->cV[k3 ], SV->cV[k3+1], SV->cV[k3+2]); } } /* freeing time */ if (V) SUMA_free(V); if (iV) SUMA_free(iV); if (!FromAFNI && freecm) if (CM) SUMA_Free_ColorMap (CM); /* only free CM if it was a pointer copy from a map in SAC */ if (OptScl) SUMA_free(OptScl); if (SV) SUMA_Free_ColorScaledVect (SV); #if 0 if (SAC) SAC = SUMA_DestroyAfniColors(SAC); /* destroy SAC */ #else SAC = NULL; /* freeing is done in SUMAg_CF */ #endif SUMA_Free_CommonFields(SUMAg_CF); SUMA_RETURN (0); }
int main (int argc,char *argv[]) { /* Main */ static char FuncName[]= {"SurfQual"}; char *OutName = NULL, ext[5], *prefix = NULL, *shist=NULL; SUMA_SURFQUAL_OPTIONS *Opt; int SO_read = -1; int i, cnt, trouble, consistent = -1, eu = -1, nsi = -1, N_Spec=0; SUMA_SurfaceObject *SO = NULL; SUMA_SurfSpecFile *Spec=NULL; void *SO_name = NULL; SUMA_Boolean DoConv = NOPE, DoSphQ = NOPE, DoSelfInt = NOPE; int N_bad_nodes, N_bad_facesets; SUMA_GENERIC_ARGV_PARSE *ps=NULL; SUMA_Boolean LocalHead = NOPE; SUMA_STANDALONE_INIT; SUMA_mainENTRY; ps = SUMA_Parse_IO_Args(argc, argv, "-i;-t;-spec;-s;-sv;"); /* Allocate space for DO structure */ SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS); Opt = SUMA_SurfQual_ParseInput (argv, argc, ps); if (argc < 2) { SUMA_S_Err("Too few options"); usage_SUMA_SurfQual(ps, 0); exit (1); } /* read all surfaces */ Spec = SUMA_IO_args_2_spec(ps, &N_Spec); if (N_Spec == 0) { SUMA_S_Err("No surfaces found."); exit(1); } if (N_Spec > 1 ) { SUMA_S_Err( "Mike, you cannot mix -spec with -i or -t options " "for specifying surfaces."); exit(1); } if (Spec->N_Surfs < 1) { SUMA_S_Err("No surfaces"); exit(1); } if (Opt->self_intersect) DoSelfInt = YUP; DoConv = NOPE; DoSphQ = NOPE; if (Opt->surftype) { if (!strcmp(Opt->surftype, "-sphere")) { DoSphQ = YUP; } else { /* Don't complain anymore, maybe winding checking is all users need */ } } for (i=0; i < Spec->N_Surfs; ++i) {/* loop to read in surfaces */ /* now identify surface needed */ if (!(SO = SUMA_Load_Spec_Surf_with_Metrics(Spec, i, ps->sv[0], 0))) { SUMA_S_Err("Failed to load surface .\n"); exit(1); } fprintf(SUMA_STDERR,"\nReport for Surface %s\n", SO->Label); /* do the quality thing based on the Opt->surftype */ if (!Opt->out_prefix) prefix = SUMA_copy_string(SO->Label); else prefix = SUMA_copy_string (Opt->out_prefix); /* check the winding */ if (!SUMA_MakeConsistent (SO->FaceSetList, SO->N_FaceSet, SO->EL, 0, &trouble)) { SUMA_S_Warn( "Failed to make sure surface's mesh is consistently wound.\n" "You should fix the mesh.\n"); consistent = 0; } { int iii=0, isbad=0, ht0; int *badedge=(int*)SUMA_calloc(SO->N_Node, sizeof(int)); /* check on troubled edges */ while (iii < SO->EL->N_EL) { ht0 = SO->EL->ELps[iii][1]; /* make sure edge is not part of three triangles, if it is,skip it*/ if (SO->EL->ELps[iii][2] > 2) { ++iii; fprintf( SUMA_STDERR, "%s: Bad edge (#%d: %d--%d), \n" " part of more than 2 triangles, skip it\n", FuncName, i, SO->EL->EL[iii][0], SO->EL->EL[iii][1]); ++badedge[SO->EL->EL[iii][0]]; ++badedge[SO->EL->EL[iii][1]]; isbad = 1; continue; } ++iii; } if (isbad) { if (Spec->N_Surfs > 1) { sprintf(ext,"_%c", 65+i); OutName = SUMA_append_replace_string ( prefix, "_BadEdgeNodes.1D.dset", ext, 0); } else { OutName = SUMA_append_string (prefix, "_BadEdgeNodes.1D.dset"); } SUMA_WRITE_ARRAY_1D(badedge,SO->N_Node,1,OutName); if (OutName) SUMA_free(OutName); OutName = NULL; } SUMA_free(badedge); badedge = NULL; } if (DoConv) { float *Cx = NULL; if (Spec->N_Surfs > 1) { sprintf(ext,"_%c", 65+i); OutName = SUMA_append_replace_string (prefix, "_Conv_detail.1D.dset", ext, 0); } else { OutName = SUMA_append_string (prefix, "_Conv_detail.1D.dset"); } Cx = SUMA_Convexity_Engine ( SO->NodeList, SO->N_Node, SO->NodeNormList, SO->FN, OutName, NULL); if (Cx) SUMA_free(Cx); Cx = NULL; if (OutName) SUMA_free(OutName); OutName = NULL; } if (DoSphQ) { if (Spec->N_Surfs > 1) { sprintf(ext,"_%c", 65+i); OutName = SUMA_append_string (prefix, ext); } else { OutName = SUMA_copy_string (prefix); } shist = SUMA_HistString (NULL, argc, argv, NULL); SUMA_SphereQuality (SO, OutName, shist, &N_bad_nodes, &N_bad_facesets); if (shist) SUMA_free(shist); shist = NULL; if (OutName) SUMA_free(OutName); OutName = NULL; } if (trouble) { /* put winding problem here to make it visible */ fprintf (SUMA_STDERR,"\n"); SUMA_S_Warn( "Mesh is not consistent, use ConvertSurface's -make_consistent \n" "option to fix the problem before proceeding further.\n" "Other results reported by this and other programs\n" "may be incorrect if mesh is not consistently wound.\n" ); consistent = 0; } else { consistent = 1; fprintf (SUMA_STDERR,"\n"); fprintf (SUMA_STDERR,"Surface is consistently wound\n"); } { SUMA_EULER_SO(SO, eu); fprintf (SUMA_STDERR,"\n"); fprintf(SUMA_STDERR,"Surface Euler Characteristic is: %d\n", eu); } if ((SO->EL->min_N_Hosts == 1 || SO->EL->max_N_Hosts == 1)) { fprintf (SUMA_STDERR,"\n"); fprintf(SUMA_STDERR, "Warning %s:\n" " Min/Max number of edge hosting triangles: [%d/%d] \n", FuncName, SO->EL->min_N_Hosts, SO->EL->max_N_Hosts); fprintf( SUMA_STDERR, " You have edges that form a border in the surface.\n"); } if (SO->EL->min_N_Hosts == 2 && SO->EL->max_N_Hosts == 2) { fprintf (SUMA_STDERR,"\n"); fprintf(SUMA_STDERR,"Surface is closed and is a 2-manifold."); } if (SO->EL->min_N_Hosts > 2 || SO->EL->max_N_Hosts > 2) { fprintf (SUMA_STDERR,"\n"); fprintf( SUMA_STDERR, "Warning %s:\n" "Min/Max number of edge hosting triangles: [%d/%d] \n", FuncName, SO->EL->min_N_Hosts, SO->EL->max_N_Hosts); fprintf(SUMA_STDERR, "Warning %s:\n" " You have edges that belong to more than two triangles.\n" " Bad for analysis assuming surface is a 2-manifold.\n", FuncName); if (1) { int iii=0; fprintf( SUMA_STDERR, " These edges are formed by the following nodes:\n"); for (iii = 0; iii < SO->EL->N_EL; ++iii) { if (SO->EL->ELps[iii][2] > 2) fprintf (SUMA_STDERR, " %d: Edge [%d %d] shared by %d triangles.\n", iii+1, SO->EL->EL[iii][0], SO->EL->EL[iii][1] , SO->EL->ELps[iii][2] ); } } } if (DoSelfInt) { int iii; FILE *fout=NULL; byte *report = (byte *)SUMA_calloc(SO->N_Node, sizeof(byte)); if (!report) { SUMA_SL_Crit("Failed to allocate for report"); report = NULL; } fprintf( SUMA_STDERR, "\n\nChecking for intersections...:\n"); nsi = SUMA_isSelfIntersect(SO, 500, report); if (nsi) { fprintf( SUMA_STDERR, " Surface is self intersecting.\n" "%d segments were found to intersect the surface.\n", nsi); if (nsi >= 500) { fprintf( SUMA_STDERR, " It is possible that you have additional segments" " intersecting the surface.\n"); } if (report) { if (Spec->N_Surfs > 1) { sprintf(ext,"_%c", 65+i); OutName = SUMA_append_replace_string ( prefix, "_IntersNodes.1D.dset", ext, 0); } else { OutName = SUMA_append_string (prefix, "_IntersNodes.1D.dset"); } fout = fopen(OutName, "w"); if (fout) { fprintf(fout, "#List of nodes that are part of segments which intersect " "the surface\n" "#%s\n" "#A total of %d segments (search limit is 500) were found to " "intersect the surface.\n" "#Col.1 : Node index\n" "#Col.2 : Dummy flag, always 1\n", SUMA_CHECK_NULL_STR(SO->Label), nsi ); for (iii=0; iii<SO->N_Node; ++iii) if (report[iii]) fprintf(fout, "%d\t1\n", iii); fclose(fout); fout = NULL; } else { SUMA_SL_Err("Failed to open file for output."); } if (OutName) SUMA_free(OutName); } } else { fprintf(SUMA_STDERR, " Surface is not self intersecting.\n"); } if (report) SUMA_free(report); report = NULL; } fprintf (SUMA_STDERR,"\n"); if (Opt->DoSum) { /* do not change syntax, scripts depend on this */ fprintf(stdout,"Summary for %s:\n", SO->Label); fprintf(stdout,"Euler_Charac. %d\n", eu); fprintf(stdout,"Consistent_Winding %d\n", consistent); if (DoSphQ) { fprintf(stdout,"Folding_Triangles %d\n", N_bad_facesets); fprintf(stdout,"Sketchy_nodes %d\n", N_bad_nodes); } if (DoSelfInt) fprintf(stdout,"Self_Intersections %d\n", nsi); fprintf(stdout,"\n"); } } SUMA_LH("clean up"); if (!SUMA_FreeSpecFields(Spec)) { SUMA_S_Err("Failed to free spec fields"); } SUMA_free(Spec); Spec = NULL; if (prefix) SUMA_free(prefix); prefix = NULL; if (Opt->out_prefix) SUMA_free(Opt->out_prefix); Opt->out_prefix = NULL; if (Opt) SUMA_free(Opt); if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) { SUMA_SL_Err("DO Cleanup Failed!"); } if (!SUMA_Free_CommonFields(SUMAg_CF)) SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1); SUMA_RETURN(0); }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"SUMA_TestDsetIO"}; int *NodeDef=NULL; byte *maskrow, *maskcol; int i, i3, N_NodeDef, N_Alloc, flg; float *r=NULL, *g=NULL, *b=NULL, *rgb=NULL; char stmp[500], idcode[50], **s, *si, *OutName = NULL; NI_element *nel=NULL; NI_stream ns; int found = 0, NoStride = 0; byte *bt=NULL; SUMA_DSET * dset = NULL, *ndset=NULL; SUMA_Boolean LocalHead = NOPE; SUMA_STANDALONE_INIT; SUMA_mainENTRY; LocalHead = YUP; /* turn on debugging */ SUMA_LH("Creating Data ..."); /* Create some sample data*/ /* let us create some colors to go on each node */ N_Alloc = 50; NodeDef = (int *)SUMA_malloc(N_Alloc * sizeof(int)); r = (float *)SUMA_malloc(N_Alloc * sizeof(float)); g = (float *)SUMA_malloc(N_Alloc * sizeof(float)); b = (float *)SUMA_malloc(N_Alloc * sizeof(float)); bt = (byte *)SUMA_malloc(N_Alloc * sizeof(byte)); s = (char **)SUMA_malloc(N_Alloc * sizeof(char *)); maskrow = (byte *)SUMA_malloc(N_Alloc * sizeof(byte)); maskcol = (byte *)SUMA_malloc(10*sizeof(byte)); for (i=0; i<10; ++i) { if (i==1 || i == 3) maskcol[i]=0; else maskcol[i] = 1; } N_NodeDef = N_Alloc; for (i=0; i<N_NodeDef; ++i) { NodeDef[i] = i; r[i] = sin((float)i/N_NodeDef*5); g[i] = sin((float)i/N_NodeDef*10); b[i] = cos((float)i/N_NodeDef*7); bt[i] = (byte)(4*b[i]); sprintf(stmp,"teststr_%d", i); s[i] = SUMA_copy_string(stmp); if (i==3 || i== 7 || i==33) maskrow[i] = 1; else maskrow[i]=0; } /* what if you had a vector of say, triplets */ rgb = (float *)SUMA_malloc(3 * N_Alloc * sizeof(float)); for (i=0; i<N_NodeDef; ++i) { i3 = 3*i; rgb[i3] = r[i]; rgb[i3+1] = g[i]; rgb[i3+2] = b[i]; } { float *xc, *de, *amp; int dof; float par[3]; /* store some statistics */ xc = (float *)SUMA_malloc(N_Alloc * sizeof(float)); de = (float *)SUMA_malloc(N_Alloc * sizeof(float)); amp = (float *)SUMA_malloc(N_Alloc * sizeof(float)); for (i=0; i<N_NodeDef; ++i) { xc[i] = rand()%1000/1000.0 * 1.0; de[i] = rand()%1000/1000.0 * 30; amp[i] = rand()%1000/1000.0 * 5.0; } SUMA_LH("Creating dset pointer"); dset = SUMA_CreateDsetPointer( "ExpandingRing_ResponseDelay", /* some label */ SUMA_NODE_BUCKET, /* mix and match */ NULL, /* no idcode, let the function create one from the filename*/ NULL, /* no domain str specified */ N_Alloc /* Number of nodes allocated for */ ); /* DO NOT free dset, if it is stored in DsetList */ #ifdef SUMA_COMPILED SUMA_LH("inserting dset pointer into list"); if (!SUMA_InsertDsetPointer(&dset, SUMAg_CF->DsetList,0)) { SUMA_SL_Err("Failed to insert dset into list"); exit(1); } #endif /* form the dataset */ SUMA_LH("Adding stat NodeDef column ..."); if (!SUMA_AddDsetNelCol ( dset, /* the famed nel */ "Node Indices", SUMA_NODE_INDEX, /* the column's type (description), one of SUMA_COL_TYPE */ (void *)NodeDef, /* column pointer p, here it is the list of node indices */ NULL /* that's an optional structure containing attributes of the added column. Not used at the moment */ ,1 /* stride, useful when you need to copy a column from a multiplexed vector. Say you have in p [rgb rgb rgb rgb], to set the g column you send in p+1 for the column pointer and a stride of 3 */ )) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } SUMA_LH("Adding stat other columns..."); par[0] = 120; par[1] = 2; par[2] = 2; if (!SUMA_AddDsetNelCol (dset, "XcorrCoef", SUMA_NODE_XCORR, (void *)xc, (void *)par ,1)) { fprintf (stderr, "Error %s:\nFailed in SUMA_AddDsetNelCol", FuncName); exit(1); } if (!SUMA_AddDsetNelCol (dset, "Delay", SUMA_NODE_FLOAT, (void *)de, NULL ,1)) { fprintf (stderr, "Error %s:\nFailed in SUMA_AddDsetNelCol", FuncName); exit(1); } if (!SUMA_AddDsetNelCol (dset, "Amplitude", SUMA_NODE_FLOAT, (void *)amp, NULL ,1)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddDsetNelCol", FuncName); exit(1); } SUMA_LH("History note"); if (!SUMA_AddNgrHist(dset->ngr, FuncName, argc, argv)) { SUMA_SL_Err("History addition failed."); exit(1); } #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("SampleDset", dset, SUMA_ASCII_NIML, 1, 1); #else OutName = SUMA_WriteDset_ns ("SampleDset", dset, SUMA_ASCII_NIML, 1, 1); #endif if (!OutName) { SUMA_SL_Err("Write Failed."); } else { fprintf (stderr,"%s:\nDset written to %s\n", FuncName, OutName); SUMA_free(OutName); OutName = NULL; } #ifdef SUMA_COMPILED /* Now create a new dataset nel no need to worry about loosing previous dset because it is in SUMAg_CF->DsetList*/ #else /* free dset by hand */ SUMA_LH("Freeing datasets ..."); if (dset) SUMA_FreeDset((void *)dset); dset = NULL; #endif } SUMA_LH("Creating dset pointer"); dset = SUMA_CreateDsetPointer( "SomethingLikeFileName", /* usually the filename */ SUMA_NODE_BUCKET, /* mix and match */ NULL, /* no idcode, let the function create one from the filename*/ NULL, /* no domain str specified */ N_Alloc /* Number of nodes allocated for */ ); /* DO NOT free dset, it is store in DsetList */ #ifdef SUMA_COMPILED SUMA_LH("inserting dset pointer into list"); if (!SUMA_InsertDsetPointer(&dset, SUMAg_CF->DsetList,0)) { SUMA_SL_Err("Failed to insert dset into list"); exit(1); } #endif /* form the dataset */ SUMA_LH("Adding NodeDef column ..."); if (!SUMA_AddDsetNelCol ( dset, /* the famed nel */ "le Node Def", SUMA_NODE_INDEX, /* the column's type (description), one of SUMA_COL_TYPE */ (void *)NodeDef, /* column pointer p, here it is the list of node indices */ NULL /* that's an optional structure containing attributes of the added column. Not used at the moment */ ,1 /* stride, useful when you need to copy a column from a multiplexed vector. Say you have in p [rgb rgb rgb rgb], to set the g column you send in p+1 for the column pointer and a stride of 3 */ )) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } SUMA_LH("Adding other columns..."); NoStride = 0; if (NoStride) { /* insert separate r, g and b column */ if (!SUMA_AddDsetNelCol (dset, "Le R", SUMA_NODE_R, (void *)r, NULL ,1)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } if (!SUMA_AddDsetNelCol (dset, "Le G", SUMA_NODE_G, (void *)g, NULL ,1)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } if (!SUMA_AddDsetNelCol (dset, "Le B", SUMA_NODE_B, (void *)b, NULL ,1)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } } else { /* insert from multiplexed rgb vector */ if (!SUMA_AddDsetNelCol (dset, "le R", SUMA_NODE_R, (void *)rgb, NULL ,3 )) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } if (!SUMA_AddDsetNelCol (dset, "Le G", SUMA_NODE_G, (void *)(rgb+1), NULL ,3)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } if (!SUMA_AddDsetNelCol (dset, "Le B", SUMA_NODE_B, (void *)(rgb+2), NULL ,3)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } #if 0 SUMA_LH("Testing insert column ..."); /* Test NI_inset_column_stride here please */ if (!SUMA_InsertDsetNelCol (dset, "Le G2", SUMA_NODE_G, (void *)(rgb+1), NULL ,3, 0)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } #endif } { int suc; SUMA_LH("Where are the attributes?"); NEL_WRITE_TX(dset->ngr,"fd:1",suc); } /* add the byte column, just to check multi type nightmares */ if (!SUMA_AddDsetNelCol (dset, "Le byte moi", SUMA_NODE_BYTE, (void *)bt, NULL ,1)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } SUMA_LH("Testing write ops before adding string columns ..."); /* before adding a string column ... */ #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("Test_write_all_num", dset, SUMA_1D, 1, 1); #else OutName = SUMA_WriteDset_ns ("Test_write_all_num", dset, SUMA_1D, 1, 1); #endif if (!OutName) { SUMA_SL_Err("Write Failed."); } else { fprintf (stderr,"%s:\nDset written to %s\n", FuncName, OutName); SUMA_free(OutName); OutName = NULL; } #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("Test_writebi_all_num", dset, SUMA_BINARY_NIML, 1, 1); #else OutName = SUMA_WriteDset_ns ("Test_writebi_all_num", dset, SUMA_BINARY_NIML, 1, 1); #endif if (!OutName) { SUMA_SL_Err("Write Failed."); } else { fprintf (stderr,"%s:\nDset written to %s\n", FuncName, OutName); SUMA_free(OutName); OutName = NULL; } #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("Test_writeas_all_num", dset, SUMA_ASCII_NIML, 1, 1); #else OutName = SUMA_WriteDset_ns ("Test_writeas_all_num", dset, SUMA_ASCII_NIML, 1, 1); #endif if (!OutName) { SUMA_SL_Err("Write Failed."); } else { fprintf (stderr,"%s:\nDset written to %s\n", FuncName, OutName); SUMA_free(OutName); OutName = NULL; } /* Now shuffle some columns (then put them back) */ SUMA_S_Note("NOTE THAT SHUFFLING here does not take care of attributes inside dset, but only dnel"); NI_move_column(dset->dnel, -1, 2); SUMA_ShowNel(dset->dnel); #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("Test_writeas_all_shuff_num", dset, SUMA_ASCII_NIML, 1, 1); #else OutName = SUMA_WriteDset_ns ("Test_writeas_all_shuff_num", dset, SUMA_ASCII_NIML, 1, 1); #endif NI_move_column(dset->dnel, 2, -1); SUMA_ShowNel(dset->dnel); /* zero out some columns and test operations */ SUMA_LH("Trying masking operations"); ndset = SUMA_MaskedCopyofDset(dset, maskrow, maskcol, 1, 0); SUMA_LH("Done"); /* try also: ndset = SUMA_MaskedCopyofDset(dset, maskrow, maskcol, 0, 1); ndset = SUMA_MaskedCopyofDset(dset, maskrow, maskcol, 0, 0); ndset = SUMA_MaskedCopyofDset(dset, maskrow, NULL, 1, 0); ndset = SUMA_MaskedCopyofDset(dset, NULL, NULL, 1, 0); ndset = SUMA_MaskedCopyofDset(dset, maskrow, maskcol, 1, 0); */ if (!ndset) { SUMA_SL_Err("Failed in SUMA_MaskedCopyofDset"); } else { #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("Test_writeas_MaskedCopy_num", ndset, SUMA_ASCII_NIML, 1, 1); #else OutName = SUMA_WriteDset_ns ("Test_writeas_MaskedCopy_num", ndset, SUMA_ASCII_NIML, 1, 1); #endif if (!OutName) { SUMA_SL_Err("Write Failed."); } else { fprintf (stderr,"%s:\nDset written to %s\n", FuncName, OutName); SUMA_free(OutName); OutName = NULL; } SUMA_free(ndset); ndset = NULL; } SUMA_LH("Adding a string column"); /* add a string column, just for kicks ..*/ if (!SUMA_AddDsetNelCol (dset, "la string", SUMA_NODE_STRING, (void *)s, NULL, 1)) { fprintf (stderr,"Error %s:\nFailed in SUMA_AddNelCol", FuncName); exit(1); } /* now try to create a masked copy, this should fail */ fprintf (stderr,"%s: Attempting to mask a not all numeric dset, this should fail\n", FuncName); ndset = SUMA_MaskedCopyofDset(dset, maskrow, maskcol, 1, 0); if (ndset) { fprintf (stderr,"Error %s:\nWhat the hell? This should not be supported.", FuncName); exit(1); }else{ fprintf (stderr,"%s: Good, failed.\n", FuncName); } /* after adding a string column ... */ SUMA_LH("Writing datasets ..."); #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("Test_writeas", dset, SUMA_ASCII_NIML, 1, 1); #else OutName = SUMA_WriteDset_ns ("Test_writeas", dset, SUMA_ASCII_NIML, 1, 1); #endif if (!OutName) { SUMA_SL_Err("Write Failed."); } else { fprintf (stderr,"%s:\nDset written to %s\n", FuncName, OutName); SUMA_free(OutName); OutName = NULL; } #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("Test_writebi", dset, SUMA_BINARY_NIML, 1, 1); #else OutName = SUMA_WriteDset_ns ("Test_writebi", dset, SUMA_BINARY_NIML, 1, 1); #endif if (!OutName) { SUMA_SL_Err("Write Failed."); } else { fprintf (stderr,"%s:\nDset written to %s\n", FuncName, OutName); SUMA_free(OutName); OutName = NULL; } SUMA_LH("Writing to 1D a dataset that is not all numbers.\nThis should fail.\n"); #ifdef SUMA_COMPILED OutName = SUMA_WriteDset_s ("Test_write", dset, SUMA_1D, 1, 1); #else OutName = SUMA_WriteDset_ns ("Test_write", dset, SUMA_1D, 1, 1); #endif if (!OutName) { SUMA_SL_Err("Write Failed."); } else { fprintf (stderr,"%s:\nDset written to %s\n", FuncName, OutName); SUMA_free(OutName); OutName = NULL; } /* How about loading some data */ #ifdef SUMA_COMPILED /* Now create a new dataset nel no need to worry about loosing previous dset because it is in SUMAg_CF->DsetList*/ #else /* free dset by hand */ SUMA_LH("Freeing datasets ..."); if (dset) SUMA_FreeDset((void *)dset); dset = NULL; #endif SUMA_LH("Fresh dataset ..."); dset = SUMA_NewDsetPointer(); SUMA_LH("Reading dataset ..."); DSET_READ(dset, "file:Test_writebi.niml.dset"); if (!dset->ngr) exit(1); /* insert the baby into the list */ #ifdef SUMA_COMPILED SUMA_LH("Inserting newly read element into list\n"); if (!SUMA_InsertDsetPointer(&dset, SUMAg_CF->DsetList, 0)) { char *newid = NULL; SUMA_SL_Err("Failed to insert dset into list"); /* Now change the idcode of that baby */ newid = UNIQ_hashcode(SDSET_ID(dset)); NI_set_attribute(dset->dnel, "self_idcode", newid); SUMA_free(newid); SUMA_LH("Trying to insert dset with a new id "); if (!SUMA_InsertDsetPointer(&dset, SUMAg_CF->DsetList, 0)) { SUMA_SL_Err("Failed to insert dset into list\nI failed to succeed, snif."); exit(1); } SUMA_LH("Lovely, that worked..."); } #endif /* show me the whole thing. Don't do this for an enormous nel */ /* SUMA_ShowNel((void*)dset->nel); */ /* I want the pointer to the green column but do not know its index */ { int j, *iv, N_i; float *fp; fprintf (stderr,"---Looking for green column ---\n"); iv = SUMA_GetDsetColIndex (dset, SUMA_NODE_G, &N_i); if (!iv) { fprintf (stderr,"Error %s: Failed to find column.\n" , FuncName); } else { fprintf (stderr,"\t%d columns of type SUMA_NODE_G found.\n", N_i); if (N_i) { fprintf (stderr,"\tReporting values at index %d\n", iv[0]); fp = (float *)dset->dnel->vec[iv[0]]; /* I know we only have one such col. here */ for (j=0; j < SDSET_VECLEN(dset); ++j) { fprintf (stderr,"%f, ", fp[j]); } SUMA_free(iv); iv = NULL; } } } /* Now show me that baby,*/ SUMA_LH("I wanna Show You Some Info"); si = SUMA_DsetInfo (dset, 0); fprintf (SUMA_STDERR,"Output of DsetInfo:\n%s\n", si); SUMA_free(si); si=NULL; if (LocalHead) fprintf(stderr," %s:-\nFrenching ...\n", FuncName); /* free other stuff */ if (r) SUMA_free(r); r = NULL; if (g) SUMA_free(g); g = NULL; if (b) SUMA_free(b); b = NULL; if (rgb) SUMA_free(rgb); rgb = NULL; if (maskrow) SUMA_free(maskrow); maskrow = NULL; if (maskcol) SUMA_free(maskcol); maskcol = NULL; if (NodeDef) SUMA_free(NodeDef); NodeDef = NULL; if (s) { for (i=0; i<N_NodeDef; ++i) { if (s[i]) SUMA_free(s[i]); } SUMA_free(s); } #ifdef SUMA_COMPILED /* dset and its contents are freed in SUMA_Free_CommonFields */ if (!SUMA_Free_CommonFields(SUMAg_CF)) SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1); #else /* free dset by hand */ if (dset) SUMA_FreeDset((void *)dset); #endif SUMA_RETURN (0); }/* Main */
int main(int argc, char **argv) { static char FuncName[]={"3dSeg"}; SEG_OPTS *Opt=NULL; char *atr=NULL; float *mixfrac= NULL; int i=0; double ff; SUMA_SEND_2AFNI SS2A; SUMA_Boolean LocalHead = NOPE; SUMA_STANDALONE_INIT; SUMA_mainENTRY; SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS); Opt = Seg_Default(argv, argc); Opt = Seg_ParseInput (Opt,argv, argc); Opt->hist = tross_commandline( FuncName , argc , argv ) ; /* load the input data */ if (!(Opt->aset = Seg_load_dset( Opt->aset_name ))) { SUMA_RETURN(1); } if (!Seg_CheckOpts(Opt)) { SUMA_S_Err("Failed on option check"); SUMA_RETURN(1); } /* Load mask dataset */ if (Opt->mset_name) { if (!strncasecmp(Opt->mset_name,"auto", 4)) { byte *mm=NULL; int j; short *sb=NULL; if (!(mm = THD_automask(Opt->aset))) { SUMA_RETURN(1); } NEW_SHORTY(Opt->aset, DSET_NVALS(Opt->aset), "automask.cp", Opt->mset); sb = (short *)DSET_ARRAY(Opt->mset,0); for (j=0; j<DSET_NVOX(Opt->mset); ++j) { sb[j] = (short)mm[j]; } free(mm); mm=NULL; } else if (!(Opt->mset = Seg_load_dset( Opt->mset_name ))) { SUMA_RETURN(1); } } /* reference classes */ if (Opt->gold_name) { if (!(Opt->gold = Seg_load_dset( Opt->gold_name ))) { SUMA_RETURN(1); } } if (Opt->gold_bias_name) { if (!(Opt->gold_bias = Seg_load_dset( Opt->gold_bias_name ))) { SUMA_RETURN(1); } } if (!Opt->clss) { SUMA_S_Err("Need -classes option"); SUMA_RETURN(1); } /* Talk ? */ if (Opt->ps->cs->talk_suma) { Opt->ps->cs->istream = SUMA_BRAINWRAP_LINE; Opt->ps->cs->afni_istream = SUMA_AFNI_STREAM_INDEX2; if (!SUMA_SendToAfni (Opt->ps->cs, NULL, 0)) { SUMA_SL_Err("Failed to initialize SUMA_SendToAfni"); Opt->ps->cs->afni_Send = NOPE; Opt->ps->cs->Send = NOPE; } else { /* send in_vol to afni */ SUMA_SL_Note("Sending anat volume to AFNI"); SS2A.dset = Opt->aset; SS2A.at_sb=-1; if (!SUMA_SendToAfni(Opt->ps->cs, &SS2A, 1)) { SUMA_SL_Err("Failed to send volume to AFNI"); Opt->ps->cs->afni_Send = NOPE; } } } /* classified set ? */ if (Opt->this_cset_name) { /* user supplied initializer */ if (!(Opt->cset = Seg_load_dset( Opt->this_cset_name ))) { SUMA_RETURN(1); } } /* labeltable? */ if (Opt->labeltable_name) { Dtable *vl_dtable=NULL; char *labeltable_str=NULL; int kk=0; /* read the table */ if (!(labeltable_str = AFNI_suck_file( Opt->labeltable_name))) { ERROR_exit("Failed to read %s", Opt->labeltable_name); } if (!(vl_dtable = Dtable_from_nimlstring(labeltable_str))) { ERROR_exit("Could not parse labeltable"); } CLASS_KEYS_FROM_LT(vl_dtable); destroy_Dtable(vl_dtable); vl_dtable=NULL; } if (!Opt->keys) { Dtable *vl_dtable=NULL; if (Opt->cset && (vl_dtable = DSET_Label_Dtable(Opt->cset))) { if (Opt->debug) SUMA_S_Note("Getting keys from -cset dataset"); /* try getting keys from cset */ CLASS_KEYS_FROM_LT(vl_dtable); /* Do not delete vl_dtable, it is the same pointer in Opt->cset */ } else { /* add default keys */ if (Opt->debug) SUMA_S_Note("Keys not available, assuming defaults"); Opt->keys = (int *)calloc(Opt->clss->num, sizeof(int)); for (i=0; i<Opt->clss->num; ++i) { Opt->keys[i] = i+1; } } } /* Make sure you have no negative values and requesting bias field correction. The implementation uses log() for this so the negative values would be ill advised */ { float amin, amax; THD_subbrick_minmax(Opt->aset, 0, 1,&amin, &amax); if (amin < 0 && Opt->bias_param > 0) { SUMA_S_Err("Cannot use field bias correction on volumes with negative\n" "values. Either turn off bias field estimation with -bias_fwhm 0.0\n" "or shift the values of the input by something like:\n" " 3dcalc -a %s -expr 'a+bool(a)*%d' -prefix SHIFTED\n" "and rerun the segmentation on SHIFTED. Note the suggested shift\n" "leaves zero values unchanged.", DSET_HEADNAME(Opt->aset), (int)ceil(-amin+1.0)); exit(1); } } /* Show the match between keys and classes */ if (Opt->debug > 1) { SUMA_S_Note("Class-->key map"); SUMA_ShowClssKeys(Opt->clss->str, Opt->clss->num, Opt->keys); } if (Opt->clss->num < 2) { if (Opt->debug <= 1) { SUMA_S_Note("Class-->key map"); SUMA_ShowClssKeys(Opt->clss->str, Opt->clss->num, Opt->keys); } SUMA_S_Err("Less than 2 classes? I am out of here"); SUMA_RETURN(0); } /* Mask setup */ if (Opt->debug > 1) { SUMA_S_Note("MaskSetup"); } Opt->cmask = MaskSetup(Opt, Opt->aset, 1, &(Opt->mset), &(Opt->cmask), Opt->dimcmask, Opt->mask_bot, Opt->mask_top, &(Opt->cmask_count)); if (Opt->VoxDbg >= 0) { SUMA_S_Note("DBG setup"); fprintf(Opt->VoxDbgOut, "Command:"); for (i=0; i<argc; ++i) { fprintf(Opt->VoxDbgOut, "%s ", argv[i]); } fprintf(Opt->VoxDbgOut, "\nDebug info for voxel %d\n", Opt->VoxDbg); } Opt->cs = SUMA_New_Class_Stat(Opt->clss->str, Opt->clss->num, Opt->keys, 3, NULL); /* Load prob. of class given features */ if (Opt->priCgAname && strcmp(Opt->priCgAname, "INIT_MIXFRAC")) { if (!(Opt->priCgA = Seg_load_dset(Opt->priCgAname))) { SUMA_S_Errv("Failed to read priCgA %s\n", Opt->priCgAname); SUMA_RETURN(1); } if (GRID_MISMATCH(Opt->priCgA, Opt->aset)) { SUMA_S_Err("All input data must have same grid (-priCgA != -aset)"); SUMA_RETURN(1); } /* Make sure dset is properly formatted */ if (!SUMA_ShortizeProbDset(&Opt->priCgA, Opt->cs, Opt->cmask, Opt->cmask_count, Opt, &Opt->priCgA)) { SUMA_S_Errv("Failed to shortize priCgA %s\n", Opt->priCgAname); SUMA_RETURN(1); } /* set the floor of the input dset */ if (0) { SUMA_S_Note("Setting probability floor, USEFULNESS NOT TESTED..."); if (!set_p_floor(Opt->priCgA, 0.1, Opt->cmask)) { SUMA_S_Errv("Failed to set p floor for priCgA %s\n", Opt->priCgAname); SUMA_RETURN(1); } } } else { /* uniform probability */ } /* Load prob. of class given location */ if (Opt->priCgLname && strcmp(Opt->priCgLname, "INIT_MIXFRAC")) { if (!(Opt->priCgL = Seg_load_dset(Opt->priCgLname))) { SUMA_S_Errv("Failed to read priCgL %s\n", Opt->priCgLname); SUMA_RETURN(1); } if (GRID_MISMATCH(Opt->priCgL, Opt->aset)) { SUMA_S_Err("All input data must have same grid (-priCgL != -aset)"); SUMA_RETURN(1); } /* Make sure dset is properly formatted */ if (!SUMA_ShortizeProbDset(&Opt->priCgL, Opt->cs, Opt->cmask, Opt->cmask_count, Opt, &Opt->priCgL)) { SUMA_S_Errv("Failed to shortize priCgL %s\n", Opt->priCgLname); SUMA_RETURN(1); } } else { /* uniform probability */ } /* check on weights of priors */ if (Opt->wA >= 0.0 && Opt->wL < 0.0) { Opt->wL = 1.0 - Opt->wA; } else if (Opt->wL >= 0.0 && Opt->wA < 0.0) { Opt->wA = 1.0 - Opt->wL; } else if (Opt->wA < 0.0 && Opt->wL < 0.0) { /* defaults */ Opt->wA = 0.5; Opt->wL = 0.5; } ff = Opt->wA+Opt->wL; Opt->wA = Opt->wA/ff; Opt->wL = Opt->wL/ff; if (!Opt->cset) { if (!SUMA_SegInitCset(Opt->aset, &Opt->cset, Opt->cmask, Opt->cmask_count, Opt->mixopt, Opt->cs, Opt)) { SUMA_S_Err("Failed to get initializer"); SUMA_RETURN(1); } } if (Opt->debug > 1) { SUMA_Seg_Write_Dset(Opt->proot, "classes_init", Opt->cset, -1, Opt->hist); } /* Now add the 'OTHER' class if needed */ if (Opt->Other) { if (!SUMA_AddOther( Opt->clss, &Opt->keys, Opt->cmask, Opt->cmask_count, Opt->cset, Opt->pstCgALL, Opt->priCgA, Opt->priCgL, Opt->cs)) { SUMA_S_Err("Failed to add other"); SUMA_RETURN(0); } } /* store mixfrac in class stats */ for (i=0;i<Opt->cs->N_label; ++i) { if ((ff = SUMA_mixopt_2_mixfrac(Opt->mixopt, Opt->cs->label[i], Opt->cs->keys[i], Opt->cs->N_label, Opt->cmask, Opt->cset))<0.0) { SUMA_S_Errv("Can't get mixfrac for %s\n", Opt->mixopt); SUMA_RETURN(1); } SUMA_set_Stat(Opt->cs, Opt->cs->label[i], "init.mix", ff); SUMA_set_Stat(Opt->cs, Opt->cs->label[i], "mix", ff); } /* Now call the workhorse */ if (!SUMA_SegEngine(Opt)) { SUMA_S_Err("Failed in SUMA_SegEngine"); exit(1); } /* write output */ if (Opt->Bset && !Opt->this_fset_name) { tross_Append_History(Opt->Bset, Opt->hist); SUMA_Seg_Write_Dset(Opt->proot, "BiasField", /* DSET_PREFIX(Opt->Bset) */ Opt->Bset, -1, Opt->hist); } if (Opt->xset && !Opt->this_xset_name) { AFNI_FEED(Opt->ps->cs, "BiasCorrect", -1, Opt->xset); SUMA_Seg_Write_Dset(Opt->proot, "AnatUB", /* DSET_PREFIX(Opt->xset)*/ Opt->xset, -1, Opt->hist); } if (Opt->cset) { SUMA_Seg_Write_Dset(Opt->proot, "Classes", /* Opt->crefix */ Opt->cset, -1, Opt->hist); AFNI_FEED(Opt->ps->cs, "FinalClasses", -1, Opt->cset); } if (Opt->pstCgALL) { SUMA_Seg_Write_Dset(Opt->proot, "Posterior", /* Opt->prefix */ Opt->pstCgALL, -1, Opt->hist); AFNI_FEED(Opt->ps->cs, "pstCgALL-final", -1, Opt->pstCgALL); } if (Opt->aset) { SUMA_Seg_Write_Dset(Opt->proot, "Anat", Opt->aset, -1, Opt->hist); } if (Opt->debug) SUMA_S_Note("Writing Unmodulated output"); if (!(SUMA_pst_C_giv_ALL(Opt->xset, Opt->cmask, Opt->cmask_count, Opt->cs, NULL, NULL, Opt->B, Opt->T, 0, &Opt->pstCgALL))) { SUMA_S_Err("Failed in SUMA_pst_C_giv_ALL unmodulated"); SUMA_RETURN(1); } SUMA_Seg_Write_Dset(Opt->proot, "Unmodulated.p", Opt->pstCgALL, -1, Opt->hist); if (!(SUMA_assign_classes( Opt->pstCgALL, Opt->cs, Opt->cmask, &Opt->cset))) { SUMA_S_Err("Failed in assign_classes"); SUMA_RETURN(1); } SUMA_Seg_Write_Dset(Opt->proot, "Unmodulated.c", Opt->cset, -1, Opt->hist); /* all done, free */ Opt = free_SegOpts(Opt); PRINT_COMPILE_DATE ; SUMA_RETURN(0); }
/*! \brief parse the arguments for SurfSmooth program \param argv (char *) \param argc (int) \return Opt (SUMA_GETPATCH_OPTIONS *) options structure. To free it, use SUMA_free(Opt->outfile); SUMA_free(Opt->histnote); SUMA_free(Opt); */ SUMA_KUBATEST_OPTIONS *SUMA_SampBias_ParseInput( char *argv[], int argc, SUMA_KUBATEST_OPTIONS* Opt, SUMA_GENERIC_ARGV_PARSE *ps) { static char FuncName[]={"SUMA_SampBias_ParseInput"}; int kar, i, ind; char *outprefix; SUMA_Boolean brk = NOPE; SUMA_Boolean LocalHead = NOPE; SUMA_ENTRY; kar = 1; brk = NOPE; Opt->debug = 0; Opt->plimit = 50; Opt->dlimit = 1000; Opt->outfile = NULL; Opt->prefix = NULL; Opt->segdo = NULL; Opt->ps=ps; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { ps->hverb = strlen(argv[kar])>3?2:1; usage_SUMA_SampBias(ps); exit (0); } SUMA_SKIP_COMMON_OPTIONS(brk, kar); if (!brk && (strcmp(argv[kar], "-plimit") == 0)) { kar++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -plimit \n"); exit (1); } Opt->plimit = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-dlimit") == 0)) { kar++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -dlimit \n"); exit (1); } Opt->dlimit = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-out") == 0)) { kar++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -out \n"); exit (1); } Opt->outfile = SUMA_copy_string(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-segdo") == 0)) { kar++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -segdo \n"); exit (1); } Opt->segdo = SUMA_Extension(argv[kar], ".1D.do", NOPE); brk = YUP; } if (!brk && (strcmp(argv[kar], "-prefix") == 0)) { kar++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -prefix \n"); exit (1); } Opt->prefix = SUMA_copy_string(argv[kar]); brk = YUP; } if (!brk && !ps->arg_checked[kar]) { SUMA_S_Errv("Option %s not understood. Try -help for usage\n", argv[kar]); suggest_best_prog_option(argv[0], argv[kar]); exit (1); } else { brk = NOPE; kar ++; } } /* sanity checks */ if (Opt->outfile == NULL && Opt->prefix == NULL) { SUMA_SL_Err("No outfile, or prefix specified."); exit(1); } if (Opt->outfile) { if (!THD_ok_overwrite() && SUMA_filexists(Opt->outfile)) { SUMA_S_Errv("Outfile %s already exists\n", Opt->outfile); exit(1); } } if (Opt->prefix) { SUMA_DSET_NAME_CHECK(Opt->prefix); } Opt->histnote = SUMA_HistString (NULL, argc, argv, NULL); SUMA_RETURN (Opt); }
/*! \brief parse the arguments for SurfSmooth program \param argv (char *) \param argc (int) \return Opt (SUMA_SURFCLUST_OPTIONS *) options structure. To free it, use SUMA_free(Opt->out_name); SUMA_free(Opt); */ SUMA_SURFCLUST_OPTIONS *SUMA_SurfClust_ParseInput (char *argv[], int argc, SUMA_GENERIC_ARGV_PARSE *ps) { static char FuncName[]={"SUMA_SurfClust_ParseInput"}; SUMA_SURFCLUST_OPTIONS *Opt=NULL; int kar, i, ind; char *outname; SUMA_Boolean brk = NOPE; SUMA_Boolean LocalHead = NOPE; SUMA_ENTRY; Opt = SUMA_create_SurfClust_Opt("SurfClust"); kar = 1; outname = NULL; BuildMethod = SUMA_OFFSETS2_NO_REC; brk = NOPE; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { usage_SUMA_SurfClust(strlen(argv[kar]) > 3 ? 2:1); exit (0); } SUMA_SKIP_COMMON_OPTIONS(brk, kar); if (!brk && (strcmp(argv[kar], "-no_cent") == 0)) { Opt->DoCentrality = 0; brk = YUP; } if (!brk && (strcmp(argv[kar], "-cent") == 0)) { Opt->DoCentrality = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-O2") == 0)) { BuildMethod = SUMA_OFFSETS2; brk = YUP; } if (!brk && (strcmp(argv[kar], "-O2_NR") == 0)) { BuildMethod = SUMA_OFFSETS2_NO_REC; brk = YUP; } if (!brk && (strcmp(argv[kar], "-Oll") == 0)) { BuildMethod = SUMA_OFFSETS_LL; brk = YUP; } if (!brk && (strcmp(argv[kar], "-update") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -update \n"); exit (1); } Opt->update = atof(argv[kar]); if (Opt->update < 1 || Opt->update > 100) { fprintf (SUMA_STDERR, "-update needs a parameter between " "1 and 50 (I have %.1f)\n", Opt->update); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-prefix") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -prefix \n"); exit (1); } Opt->oform = SUMA_GuessFormatFromExtension(argv[kar], NULL); if (Opt->oform == SUMA_NO_DSET_FORMAT) Opt->oform = SUMA_ASCII_NIML; Opt->out_prefix = SUMA_RemoveDsetExtension_s(argv[kar], Opt->oform); Opt->WriteFile = YUP; brk = YUP; } #if 0 if (!brk && (strcmp(argv[kar], "-spec") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -spec \n"); exit (1); } Opt->spec_file = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-sv") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -sv \n"); exit (1); } Opt->sv_name = argv[kar]; brk = YUP; } if (!brk && (strncmp(argv[kar], "-surf_", 6) == 0)) { if (kar + 1>= argc) { fprintf (SUMA_STDERR, "need argument after -surf_X SURF_NAME \n"); exit (1); } ind = argv[kar][6] - 'A'; if (ind < 0 || ind >= SURFCLUST_MAX_SURF) { fprintf (SUMA_STDERR, "-surf_X SURF_NAME option is out of range.\n" "Only %d surfaces are allowed. \n" "Must start with surf_A for first surface.\n", SURFCLUST_MAX_SURF); exit (1); } kar ++; Opt->surf_names[ind] = argv[kar]; Opt->N_surf = ind+1; brk = YUP; } #endif if (!brk && (strcmp(argv[kar], "-input") == 0)) { kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need 2 arguments after -input \n"); exit (1); } Opt->in_name = argv[kar]; kar ++; /* no need for that one Opt->nodecol = atoi(argv[kar]); kar ++; */ Opt->labelcol = atoi(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-rmm") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -rmm \n"); exit (1); } Opt->DistLim = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-in_range") == 0)) { kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need two arguments after -in_range \n"); exit (1); } Opt->DoThreshold = SUMA_THRESH_INSIDE_RANGE; Opt->ThreshR[0] = atof(argv[kar]); ++kar; Opt->ThreshR[1] = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-ex_range") == 0)) { kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need two arguments after -ex_range \n"); exit (1); } Opt->DoThreshold = SUMA_THRESH_OUTSIDE_RANGE; Opt->ThreshR[0] = atof(argv[kar]); ++kar; Opt->ThreshR[1] = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-thresh") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -thresh \n"); exit (1); } Opt->DoThreshold = SUMA_LESS_THAN; Opt->ThreshR[0] = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-athresh") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -athresh \n"); exit (1); } Opt->DoThreshold = SUMA_ABS_LESS_THAN; Opt->ThreshR[0] = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-thresh_col") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -thresh_col \n"); exit (1); } Opt->tind = atoi(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-amm2") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -amm2 \n"); exit (1); } Opt->AreaLim = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-n") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need argument after -n \n"); exit (1); } Opt->NodeLim = atoi(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-out_roidset") == 0)) { Opt->OutROI = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-prepend_node_index") == 0)) { Opt->prepend_node_index = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-out_clusterdset") == 0)) { Opt->OutClustDset = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-out_fulllist") == 0)) { Opt->FullROIList = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-sort_none") == 0)) { Opt->SortMode = SUMA_SORT_CLUST_NO_SORT; brk = YUP; } if (!brk && (strcmp(argv[kar], "-sort_n_nodes") == 0)) { Opt->SortMode = SUMA_SORT_CLUST_BY_NUMBER_NODES; brk = YUP; } if (!brk && (strcmp(argv[kar], "-sort_area") == 0)) { Opt->SortMode = SUMA_SORT_CLUST_BY_AREA; brk = YUP; } if (!brk && !ps->arg_checked[kar]) { SUMA_S_Errv("Option %s not understood.\n" "Try -help for usage\n", argv[kar]); suggest_best_prog_option(argv[0], argv[kar]); exit (1); } else { brk = NOPE; kar ++; } } /* sanitorium */ if (Opt->DistLim == -1.5f) { fprintf (SUMA_STDERR, "must use option -rmm \n"); exit(1); } if (!Opt->out_prefix) { Opt->out_prefix = SUMA_RemoveDsetExtension_s(Opt->in_name, SUMA_NO_DSET_FORMAT); } if (Opt->SortMode == SUMA_SORT_CLUST_NOT_SET) { Opt->SortMode = SUMA_SORT_CLUST_BY_AREA; } if (BuildMethod == SUMA_OFFSETS2) { SUMA_S_Note("Using Offsets2"); } else if (BuildMethod == SUMA_OFFSETS_LL) { SUMA_S_Note("Using Offsets_ll"); } else if (BuildMethod == SUMA_OFFSETS2_NO_REC) { if (LocalHead) SUMA_S_Note("Using no recursion"); } else { SUMA_SL_Err("Bad BuildMethod"); exit(1); } SUMA_SurfClust_Set_Method(BuildMethod); if (Opt->FullROIList && !(Opt->OutROI || Opt->OutClustDset)) { SUMA_SL_Err("-out_fulllist must be used in conjunction " "with -out_ROIdset or -out_clusterdset"); exit(1); } SUMA_RETURN(Opt); }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"SurfClust"}; int kar, SO_read, *ni=NULL, N_ni, cnt, i, *nip=NULL, N_Spec = 0; float *data_old = NULL, *far = NULL, *nv=NULL, *nt = NULL; void *SO_name = NULL; SUMA_SurfaceObject *SO = NULL, *SOnew = NULL; MRI_IMAGE *im = NULL; SUMA_DSET_FORMAT iform; SUMA_SURFCLUST_OPTIONS *Opt; SUMA_SurfSpecFile *Spec=NULL; DList *list = NULL; SUMA_DSET *dset = NULL; float *NodeArea = NULL; FILE *clustout=NULL; char *ClustOutName = NULL, *params=NULL, stmp[200]; char sapa[32]={""}, sapd[32]={""}, sapn[32]={""}, sap[100]={""}; SUMA_GENERIC_ARGV_PARSE *ps=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, "-spec;-i;-t;-sv;-s;"); Opt = SUMA_SurfClust_ParseInput (argv, argc, ps); if (argc < 6) { SUMA_S_Err("Too few options"); usage_SUMA_SurfClust(0); exit (1); } if (Opt->DistLim >= 0.0) { sprintf(sapd, "_r%.1f", Opt->DistLim); } else { sprintf(sapd, "_e%d", -(int)Opt->DistLim); } if (Opt->AreaLim < 0) { sapa[0]='\0'; } else { sprintf(sapa, "_a%.1f", Opt->AreaLim); } if (Opt->NodeLim < 0) { sapn[0]='\0'; } else { sprintf(sapn, "_n%d", Opt->NodeLim); } sprintf(sap, "%s%s%s", sapd, sapa, sapn); if (Opt->WriteFile) { sprintf(stmp,"_ClstTable%s.1D", sap); ClustOutName = SUMA_append_string(Opt->out_prefix, stmp); if (SUMA_filexists(ClustOutName) && !THD_ok_overwrite()) { fprintf (SUMA_STDERR, "Error %s:\n" "Output file %s exists, will not overwrite.\n", FuncName, ClustOutName); exit(1); } } Spec = SUMA_IO_args_2_spec(ps, &N_Spec); if (N_Spec == 0) { SUMA_S_Err("No surfaces found."); exit(1); } if (N_Spec != 1) { SUMA_S_Err("Multiple spec at input."); exit(1); } if (Spec->N_Surfs != 1) { SUMA_S_Err("1 and only 1 surface expected at input"); exit(1); } SUMA_LH("Loading surface..."); SO = SUMA_Load_Spec_Surf(Spec, 0, ps->sv[0], 0); if (!SO) { fprintf (SUMA_STDERR,"Error %s:\n" "Failed to find surface\n" "in spec file. \n", FuncName ); exit(1); } if (!SUMA_SurfaceMetrics(SO, "EdgeList", NULL)) { SUMA_S_Err("Failed to compute edgelist"); exit(1); } NodeArea = SUMA_CalculateNodeAreas(SO, NULL); if (!NodeArea) { SUMA_S_Err("Failed to calculate Node Areas.\n"); exit(1); } /* load the data */ iform = SUMA_NO_DSET_FORMAT; dset = SUMA_LoadDset_s (Opt->in_name, &iform, 0); if (LocalHead) SUMA_ShowDset(dset, 0, NULL); if (!dset) { SUMA_S_Err( "Failed to load dataset.\n" "Make sure file exists\n" "and is of the specified\n" "format."); exit(1); } if (!SUMA_OKassign(dset, SO)) { SUMA_SL_Err("Failed to assign data set to surface."); exit(1); } /* get the node index column */ nip = SUMA_GetNodeDef(dset); N_ni = SDSET_VECLEN(dset); if (!nip) { SUMA_S_Err("Failed to find node index column"); exit(1); } /* copy nip's contents because you will be modifying in the thresholding below */ ni = (int *)SUMA_malloc(N_ni*sizeof(int)); memcpy (ni, nip, N_ni*sizeof(int)); nv = SUMA_DsetCol2Float(dset, Opt->labelcol, 0); if (!nv) { SUMA_S_Err("Failed to find node value column"); exit(1); } /* any thresholding ? */ if (Opt->DoThreshold > SUMA_NO_THRESH) { nt = SUMA_DsetCol2Float(dset, Opt->tind, 0); if (!nt) { SUMA_S_Err("Failed to find threshold column"); exit(1); } cnt = 0; if (Opt->DoThreshold == SUMA_LESS_THAN) { if (Opt->update) fprintf( SUMA_STDERR, "%s: Thresholding at %f...\n", FuncName, Opt->ThreshR[0]); for (i=0;i<N_ni; ++i) { if (nt[i] >= Opt->ThreshR[0]) { ni[cnt] = ni[i]; nv[cnt] = nv[i]; ++cnt; } } } else if (Opt->DoThreshold == SUMA_ABS_LESS_THAN) { SUMA_LH("ABS Thresholding at %f...", Opt->ThreshR[0]); for (i=0;i<N_ni; ++i) { if (fabs(nt[i]) >= Opt->ThreshR[0]) { ni[cnt] = ni[i]; nv[cnt] = nv[i]; ++cnt; } } } else if (Opt->DoThreshold == SUMA_THRESH_INSIDE_RANGE) { SUMA_LH("Range Thresholding at %f %f...", Opt->ThreshR[0], Opt->ThreshR[1]); for (i=0;i<N_ni; ++i) { if (nt[i] >= Opt->ThreshR[0] && nt[i] <= Opt->ThreshR[1]) { ni[cnt] = ni[i]; nv[cnt] = nv[i]; ++cnt; } } } else if (Opt->DoThreshold == SUMA_THRESH_OUTSIDE_RANGE) { SUMA_LH("Ex Range Thresholding at %f %f...", Opt->ThreshR[0], Opt->ThreshR[1]); for (i=0;i<N_ni; ++i) { if (nt[i] < Opt->ThreshR[0] || nt[i] > Opt->ThreshR[1]) { ni[cnt] = ni[i]; nv[cnt] = nv[i]; ++cnt; } } } else { SUMA_S_Err("Not ready for threshold mode of %d", Opt->DoThreshold); } N_ni = cnt; } if (Opt->update) { Opt->update = -(N_ni * Opt->update / 100); /* make it negative before you begin a clustering operation */ if (LocalHead) { fprintf( SUMA_STDERR, "Update parameter, once every %d nodes\n" "%d nodes to work with.\n", -(int)Opt->update, N_ni); } } /* make the call */ list = SUMA_FindClusters (SO, ni, nv, N_ni, -1, Opt, NodeArea); if (!list) { SUMA_S_Err("Failed in SUMA_FindClusters"); exit(1); } if (list->size) { /* sort the list */ if (!SUMA_Sort_ClustersList (list, Opt->SortMode)) { SUMA_S_Err("Failed to sort cluster list"); exit(1); } } /* Show the results */ params = SUMA_HistString(FuncName, argc, argv, NULL); if (Opt->WriteFile) { if (0) { /* You can also write a NIML formatted cluster table with */ NI_element *nel=NULL; int suc; char sbuf[512]={""}; nel = SUMA_SurfClust_list_2_nel(list, 0, params, NULL); snprintf(sbuf, 510, "file:%s%s.niml.clstbl", Opt->out_prefix, sap); NEL_WRITE_TXH(nel, sbuf, suc); NI_free_element(nel); nel=NULL; } clustout = fopen(ClustOutName, "w"); if (!clustout) { fprintf (SUMA_STDERR, "Error %s:\n" "Failed to open %s for writing.\n" "Check permissions.\n", FuncName, ClustOutName); exit(1); } SUMA_Show_SurfClust_list(list, clustout, 0, params, NULL); fclose(clustout);clustout = NULL; } else SUMA_Show_SurfClust_list(list, NULL, 0, params, NULL); if (!list->size) { /* nothing left to do, quit */ exit(0); } if (Opt->OutROI) { SUMA_DSET *dset_roi = NULL; char *ROIprefix = NULL; char *NameOut = NULL; sprintf(stmp,"_ClstMsk%s", sap); ROIprefix = SUMA_append_string(Opt->out_prefix, stmp); /* Call this function, write out the resultant dset to disk then cleanup */ dset_roi = SUMA_SurfClust_list_2_DsetMask(SO, list, Opt->FullROIList, ROIprefix); if (!dset_roi) { SUMA_S_Err("NULL dset_roi"); exit(1); } if (Opt->prepend_node_index) {/* prepend node index? */ if (!SUMA_InsertDsetNelCol ( dset_roi, "Node Index Copy", SUMA_NODE_INT, (void *)(dset_roi->inel->vec[0]), NULL ,1, 0)) { SUMA_S_Err("Failed to insert column"); } if (LocalHead) SUMA_ShowDset(dset_roi,0, NULL); } NameOut = SUMA_WriteDset_s ( ROIprefix, dset_roi, Opt->oform, THD_ok_overwrite(), 0); if (!NameOut) { SUMA_SL_Err("Failed to write dataset."); exit(1); } SUMA_FreeDset((void *)dset_roi); dset_roi = NULL; if (NameOut) SUMA_free(NameOut); NameOut = NULL; if (ROIprefix) SUMA_free(ROIprefix); ROIprefix = NULL; } if (Opt->OutClustDset) { SUMA_DSET *dset_clust = NULL; char *Clustprefix = NULL; char *NameOut = NULL; sprintf(stmp,"_Clustered%s", sap); Clustprefix = SUMA_append_string(Opt->out_prefix, stmp); /* Call this function, write out the resultant dset to disk then cleanup */ dset_clust = SUMA_MaskDsetByClustList( dset, SO, list, Opt->FullROIList, Clustprefix); if (!dset_clust) { SUMA_S_Err("NULL dset_clust"); exit(1); } NameOut = SUMA_WriteDset_s ( Clustprefix, dset_clust, Opt->oform, THD_ok_overwrite(), 0); if (!NameOut) { SUMA_SL_Err("Failed to write dataset."); exit(1); } SUMA_FreeDset((void *)dset_clust); dset_clust = NULL; if (NameOut) SUMA_free(NameOut); NameOut = NULL; if (Clustprefix) SUMA_free(Clustprefix); Clustprefix = NULL; } if (ClustOutName) SUMA_free(ClustOutName); ClustOutName = NULL; if (list) dlist_destroy(list); SUMA_free(list); list = NULL; if (ni) SUMA_free(ni); ni = NULL; if (nv) SUMA_free(nv); nv = NULL; if (nt) SUMA_free(nt); nt = NULL; if (Opt->out_prefix) SUMA_free(Opt->out_prefix); Opt->out_prefix = NULL; if (Opt) SUMA_free_SurfClust_Opt(Opt); if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL; if (dset) SUMA_FreeDset((void *)dset); dset = NULL; if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) { SUMA_SL_Err("DO Cleanup Failed!"); } exit(0); }
int main (int argc,char *argv[]) {/* Main */ static char FuncName[]={"ConvertSurface"}; int kar, volexists, i, j, Doinv, randseed, Domergesurfs=0, pciref; float DoR2S, fv[3], *pcxyzref; double xcen[3], sc[3]; double xform[4][4]; char *if_name = NULL, *of_name = NULL, *if_name2 = NULL, *of_name2 = NULL, *sv_name = NULL, *vp_name = NULL, *OF_name = NULL, *OF_name2 = NULL, *tlrc_name = NULL, *acpc_name=NULL, *xmat_name = NULL, *ifpar_name = NULL, *ifpar_name2 = NULL; SUMA_SO_File_Type iType = SUMA_FT_NOT_SPECIFIED, iparType = SUMA_FT_NOT_SPECIFIED, oType = SUMA_FT_NOT_SPECIFIED; SUMA_SO_File_Format iForm = SUMA_FF_NOT_SPECIFIED, iparForm = SUMA_FF_NOT_SPECIFIED, oFormat = SUMA_FF_NOT_SPECIFIED; SUMA_SurfaceObject *SO = NULL, *SOpar = NULL, *SOsurf = NULL; SUMA_PARSED_NAME *of_name_strip = NULL, *of_name2_strip = NULL; SUMA_SFname *SF_name = NULL; void *SO_name = NULL; char orsurf[6], orcode[6], *PCprojpref=NULL, *NodeDepthpref=NULL; THD_warp *warp=NULL ; THD_3dim_dataset *aset=NULL; SUMA_Boolean brk, Do_tlrc, Do_mni_RAI, Do_mni_LPI, Do_acpc, Docen, Do_flip; SUMA_Boolean Doxmat, Do_wind, Do_p2s, onemore, Do_native, Do_PolDec; int Do_PCproj, Do_PCrot, Do_NodeDepth; SUMA_GENERIC_ARGV_PARSE *ps=NULL; SUMA_Boolean exists; 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, "-o;-i;-sv;-ipar;"); kar = 1; xmat_name = NULL; xcen[0] = 0.0; xcen[1] = 0.0; xcen[2] = 0.0; brk = NOPE; orcode[0] = '\0'; randseed = 1234; sprintf(orsurf,"RAI"); Docen = NOPE; Doxmat = NOPE; Do_tlrc = NOPE; Do_mni_RAI = NOPE; Do_mni_LPI = NOPE; Do_acpc = NOPE; Do_wind = NOPE; Do_flip = NOPE; Do_p2s = NOPE; Do_native = NOPE; DoR2S = 0.0; Do_PolDec = NOPE; Do_PCproj = NO_PRJ; Do_PCrot = NO_ROT; pciref = -1; pcxyzref = NULL; PCprojpref = NULL; NodeDepthpref = NULL; Do_NodeDepth = 0; Doinv = 0; Domergesurfs = 0; onemore = NOPE; while (kar < argc) { /* loop accross command ine options */ /*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/ if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) { usage_SUMA_ConvertSurface(ps, strlen(argv[kar]) > 3 ? 2:1); exit (0); } SUMA_SKIP_COMMON_OPTIONS(brk, kar); SUMA_TO_LOWER(argv[kar]); if (!brk && (strcmp(argv[kar], "-seed") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 integer after -seed\n"); exit (1); } randseed = atoi(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-xyzscale") == 0)) { kar ++; if (kar+2 >= argc) { fprintf (SUMA_STDERR, "need 3 values after -XYZscale\n"); exit (1); } sc[0] = strtod(argv[kar], NULL); kar ++; sc[1] = strtod(argv[kar], NULL); kar ++; sc[2] = strtod(argv[kar], NULL); xmat_name = "Scale"; Doxmat = YUP; Doinv = 0; brk = YUP; } if (!brk && ( (strcmp(argv[kar], "-xmat_1d") == 0) || (strcmp(argv[kar], "-xmat_1D") == 0) ) ) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 argument after -xmat_1D\n"); exit (1); } xmat_name = argv[kar]; Doxmat = YUP; Doinv = 0; brk = YUP; } if (!brk && ( (strcmp(argv[kar], "-ixmat_1d") == 0) || (strcmp(argv[kar], "-ixmat_1D") == 0) ) ) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 argument after -ixmat_1D\n"); exit (1); } xmat_name = argv[kar]; Doxmat = YUP; Doinv = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-polar_decomp") == 0)) { Do_PolDec = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-merge_surfs") == 0)) { Domergesurfs = 1; brk = YUP; } if (!brk && (strcmp(argv[kar], "-pc_proj") == 0)) { kar ++; if (kar+1 >= argc) { fprintf (SUMA_STDERR, "need 2 argument after -pc_proj\n"); exit (1); } if (!strcmp(argv[kar],"PC0_plane")) Do_PCproj = E1_PLN_PRJ; else if (!strcmp(argv[kar],"PC1_plane")) Do_PCproj = E2_PLN_PRJ; else if (!strcmp(argv[kar],"PC2_plane")) Do_PCproj = E3_PLN_PRJ; else if (!strcmp(argv[kar],"PCZ_plane")) Do_PCproj = EZ_PLN_PRJ; else if (!strcmp(argv[kar],"PCY_plane")) Do_PCproj = EY_PLN_PRJ; else if (!strcmp(argv[kar],"PCX_plane")) Do_PCproj = EX_PLN_PRJ; else if (!strcmp(argv[kar],"PC0_dir")) Do_PCproj = E1_DIR_PRJ; else if (!strcmp(argv[kar],"PC1_dir")) Do_PCproj = E2_DIR_PRJ; else if (!strcmp(argv[kar],"PC2_dir")) Do_PCproj = E3_DIR_PRJ; else if (!strcmp(argv[kar],"PCZ_dir")) Do_PCproj = EZ_DIR_PRJ; else if (!strcmp(argv[kar],"PCY_dir")) Do_PCproj = EY_DIR_PRJ; else if (!strcmp(argv[kar],"PCX_dir")) Do_PCproj = EX_DIR_PRJ; else { SUMA_S_Err("Bad value of %s for -pca_proj", argv[kar]); exit(1); } ++kar; if (argv[kar][0] == '-') { SUMA_S_Err("Prefix for -pc_proj should not start with '-'.\n" "Could it be that %s is another option and \n" "the prefix was forgtotten?", argv[kar]); exit(1); } PCprojpref = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-node_depth") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need a prefix argument after -node_depth\n"); exit (1); } Do_NodeDepth = 1; if (argv[kar][0] == '-') { SUMA_S_Err("Prefix for -node_depth should not start with '-'.\n" "Could it be that %s is another option and \n" "the prefix was forgtotten?", argv[kar]); exit(1); } NodeDepthpref = argv[kar]; brk = YUP; } if (!brk && (strcmp(argv[kar], "-make_consistent") == 0)) { Do_wind = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-flip_orient") == 0)) { Do_flip = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-xcenter") == 0)) { kar ++; if (kar+2>= argc) { fprintf (SUMA_STDERR, "need 3 arguments after -xcenter\n"); exit (1); } xcen[0] = atof(argv[kar]); ++kar; xcen[1] = atof(argv[kar]); ++kar; xcen[2] = atof(argv[kar]); Docen = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-native") == 0)) { Do_native = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-orient_out") == 0)) { kar ++; if (kar>= argc) { fprintf (SUMA_STDERR, "need 1 argument after -orient_out\n"); exit (1); } snprintf(orcode, 4*sizeof(char), "%s", argv[kar]); if (!SUMA_ok_orstring(orcode)) { fprintf (SUMA_STDERR, "%s is a bad orientation string\n", orcode); exit (1); } brk = YUP; } if (!brk && (strcmp(argv[kar], "-radial_to_sphere") == 0)) { kar ++; if (kar >= argc) { fprintf (SUMA_STDERR, "need 1 argument after -radial_to_sphere\n"); exit (1); } DoR2S = atof(argv[kar]); brk = YUP; } if (!brk && (strcmp(argv[kar], "-patch2surf") == 0)) { Do_p2s = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-xml_ascii") == 0)) { oFormat = SUMA_XML_ASCII_SURF; brk = YUP; } if (!brk && (strcmp(argv[kar], "-xml_b64") == 0)) { oFormat = SUMA_XML_B64_SURF; brk = YUP; } if (!brk && (strcmp(argv[kar], "-xml_b64gz") == 0)) { oFormat = SUMA_XML_B64GZ_SURF; brk = YUP; } if (!brk && (strcmp(argv[kar], "-tlrc") == 0)) { Do_tlrc = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-acpc") == 0)) { Do_acpc = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-mni_rai") == 0)) { Do_mni_RAI = YUP; brk = YUP; } if (!brk && (strcmp(argv[kar], "-mni_lpi") == 0)) { Do_mni_LPI = YUP; brk = YUP; } if (!brk && !ps->arg_checked[kar]) { fprintf (SUMA_STDERR, "Error %s: Option %s not understood. Try -help for usage\n", FuncName, argv[kar]); suggest_best_prog_option(argv[0], argv[kar]); exit (1); } else { brk = NOPE; kar ++; } } if (argc < 3) { SUMA_S_Err("Too few options"); usage_SUMA_ConvertSurface (ps, 0); exit (1); } /* transfer info from ps structure (backward compat) */ if (ps->o_N_surfnames) { of_name = ps->o_surfnames[0]; of_name2 = ps->o_surftopo[0]; oType = ps->o_FT[0]; if (oFormat == SUMA_FF_NOT_SPECIFIED) { oFormat = ps->o_FF[0]; } } if (ps->i_N_surfnames) { if_name = ps->i_surfnames[0]; if_name2 = ps->i_surftopo[0]; iType = ps->i_FT[0]; iForm = ps->i_FF[0]; } if (ps->ipar_N_surfnames) { ifpar_name = ps->ipar_surfnames[0]; ifpar_name2 = ps->ipar_surftopo[0]; iparType = ps->ipar_FT[0]; iparForm = ps->ipar_FF[0]; } if (ps->N_sv) sv_name = ps->sv[0]; if (ps->N_vp) vp_name = ps->vp[0]; /* sanity checks */ if (Do_native && orcode[0] != '\0') { SUMA_S_Err("Options -native and -orient_out are mutually exclusive"); exit(1); } if (Do_mni_LPI && Do_mni_RAI) { SUMA_S_Err("\nCombining -MNI_lpi and -MNI_rai options.\nNot good."); exit(1); } if (!if_name) { SUMA_S_Err("input surface not specified.\n"); exit(1); } if (!of_name && (Do_PCproj < 0 && !Do_NodeDepth) ) { SUMA_S_Err("output surface or projection PREFIX not specified.\n"); exit(1); } if (iType == SUMA_FT_NOT_SPECIFIED) { SUMA_S_Err("input type not recognized.\n"); exit(1); } if (oType == SUMA_FT_NOT_SPECIFIED && (Do_PCproj < 0 && !Do_NodeDepth) ) { SUMA_S_Err("output type not recognized.\n"); exit(1); } if ( oType != SUMA_GIFTI && oFormat >= SUMA_XML_SURF && oFormat <= SUMA_XML_B64GZ_SURF && (Do_PCproj < 0 && !Do_NodeDepth) ){ SUMA_S_Err("XML output options only valid with -o_gii\n"); exit(1); } if (iType == SUMA_SUREFIT) { if (!if_name2) { SUMA_S_Err("input SureFit surface incorrectly specified.\n"); exit(1); } if (sv_name && !vp_name) { SUMA_S_Err("VolParent needs the -sv option for SureFit surfaces."); exit(1); } } if (iType == SUMA_VEC) { if (!if_name2) { SUMA_S_Err("Input vec surface incorrectly specified.\n"); exit(1); } } if (( Do_mni_RAI || Do_mni_LPI) && !Do_tlrc) { SUMA_SL_Warn ( "I hope you know what you're doing.\n" "The MNI transform should only be applied to a\n" "Surface in the AFNI tlrc coordinate space.\n"); } if (Do_acpc && Do_tlrc) { SUMA_S_Err("You can't do -tlrc and -acpc simultaneously."); exit(1); } if ((Doxmat || Docen) && (Do_acpc || Do_tlrc)) { SUMA_S_Err("You can't do -tlrc or -acpc with -xmat_1D and -xcenter.\n"); exit(1); } if ((!Doxmat && Docen)) { SUMA_S_Err("You can't use -xcenter without -xmat_1D.\n"); exit(1); } if (oType == SUMA_SUREFIT) { if (!of_name2) { SUMA_S_Err("output SureFit surface incorrectly specified. \n"); exit(1); } } if (oType == SUMA_VEC) { if (!of_name2) { SUMA_S_Err("output vec surface incorrectly specified. \n"); exit(1); } } if ( ps->i_N_surfnames > 1 && !Domergesurfs) { SUMA_S_Err("Multiple surfaces specified without -merge_surfs option\n" "Nothing to do for such an input\n"); exit(1); } /* test for existence of input files */ if (!SUMA_is_predefined_SO_name(if_name, NULL, NULL, NULL, NULL) && !SUMA_filexists(if_name)) { SUMA_S_Errv("if_name %s not found.\n", if_name); exit(1); } if (if_name2) { if (!SUMA_filexists(if_name2)) { SUMA_S_Errv("if_name2 %s not found.\n", if_name2); exit(1); } } if (ifpar_name2) { if (!SUMA_filexists(ifpar_name2)) { SUMA_S_Errv("ifpar_name2 %s not found.\n", ifpar_name2); exit(1); } } if (ifpar_name) { if (!SUMA_filexists(ifpar_name)) { SUMA_S_Errv("ifpar_name %s not found.\n", ifpar_name); exit(1); } } if (xmat_name) { if (!strstr(special_xmats,xmat_name) && !SUMA_filexists(xmat_name)) { SUMA_S_Errv("xmat file %s not found.\n", xmat_name); exit(1); } } else { if (Do_PolDec) { SUMA_S_Err("-polar_decomp is useless without -xmat_1D"); exit(1); } } if (sv_name) { char *head = NULL, view[10]; head = SUMA_AfniPrefix(sv_name, view, NULL, &volexists); if (!SUMA_AfniExistsView(volexists, view) && !SUMA_filexists(sv_name)) { fprintf (SUMA_STDERR, "Error %s: volume %s not found.\n", FuncName, head); exit(1); } if (head) SUMA_free(head); head = NULL; } if ((Do_tlrc || Do_acpc) && (!sv_name)) { fprintf (SUMA_STDERR, "Error %s: -tlrc must be used with -sv option.\n", FuncName); exit(1); } if (vp_name) { if (!SUMA_filexists(vp_name)) { fprintf (SUMA_STDERR, "Error %s: %s not found.\n", FuncName, vp_name); exit(1); } } /* check for existence of output files */ if ((Do_PCproj < 0 && !Do_NodeDepth) ) { if (of_name2) { SUMA_SFname *SFname; SO_name = SUMA_2Prefix2SurfaceName (of_name, of_name2, NULL, vp_name, oType, &exists); SFname = (SUMA_SFname *)SO_name; OF_name2 = SUMA_copy_string(SFname->name_topo); OF_name = SUMA_copy_string(SFname->name_coord); } else { SO_name = SUMA_Prefix2SurfaceName (of_name, NULL, vp_name, oType, &exists); OF_name = SUMA_copy_string((char *) SO_name); } if (exists && !THD_ok_overwrite()) { if (OF_name2) fprintf (SUMA_STDERR, "Error %s: output file(s) %s and/or %s exist already.\n", FuncName, OF_name, OF_name2); else fprintf ( SUMA_STDERR, "Error %s: output file %s exists already.\n", FuncName, OF_name); exit(1); } } /* now for the real work */ if (Doxmat) { MRI_IMAGE *im = NULL; double *far=NULL; int nrow, ncol; if (!strcmp(xmat_name,"RandRigid")) { SUMA_FillRandXform(xform, randseed, 2); } else if (!strcmp(xmat_name,"RandAffine")) { SUMA_FillRandXform(xform, randseed, 3); } else if (!strcmp(xmat_name,"RandShift")) { SUMA_FillRandXform(xform, randseed, 1); } else if (!strcmp(xmat_name,"Scale")) { SUMA_FillScaleXform(xform, sc); } else if (!strcmp(xmat_name,"NegXY")) { SUMA_FillXYnegXform(xform); } else { im = mri_read_double_1D (xmat_name); if (!im) { SUMA_SLP_Err("Failed to read 1D file"); exit(1); } far = MRI_DOUBLE_PTR(im); nrow = im->nx; ncol = im->ny; if (nrow == 1) { if (ncol != 12) { SUMA_SL_Err("Mat file must have\n" "one row of 12 columns."); mri_free(im); im = NULL; /* done with that baby */ exit(1); } i = 0; while (i < 12) { xform[i/4][0] = far[i]; ++i; xform[i/4][1] = far[i]; ++i; xform[i/4][2] = far[i]; ++i; xform[i/4][3] = far[i]; ++i; } xform[3][0] = 0.0; xform[3][1] = 0.0; xform[3][2] = 0.0; xform[3][3] = 1.0; } else { if (ncol < 4 ) { SUMA_SL_Err("Mat file must have\n" "at least 4 columns."); mri_free(im); im = NULL; /* done with that baby */ exit(1); } if (nrow < 3 ) { SUMA_SL_Err("Mat file must have\n" "at least 3 rows."); mri_free(im); im = NULL; /* done with that baby */ exit(1); } if (ncol > 4) { SUMA_SL_Warn( "Ignoring entries beyond 4th \n" "column in transform file."); } if (nrow > 3) { SUMA_SL_Warn( "Ignoring entries beyond 3rd\n" "row in transform file.\n"); } for (i=0; i < 3; ++i) { xform[i][0] = far[i]; xform[i][1] = far[i+nrow]; xform[i][2] = far[i+2*nrow]; xform[i][3] = far[i+3*nrow]; } xform[3][0] = 0.0; xform[3][1] = 0.0; xform[3][2] = 0.0; xform[3][3] = 1.0; } } if (LocalHead) { fprintf(SUMA_STDERR,"\n++ ConvertSurface xform:\n"); for (i=0; i < 4; ++i) { fprintf(SUMA_STDERR," %+.5f\t%+.5f\t%+.5f\t%+.5f\n", xform[i][0], xform[i][1], xform[i][2], xform[i][3]); } fprintf(SUMA_STDERR,"\n"); } mri_free(im); im = NULL; if (Doinv) { mat44 A, A0; LOAD_MAT44( A0, \ xform[0][0], xform[0][1], xform[0][2], xform[0][3], \ xform[1][0], xform[1][1], xform[1][2], xform[1][3], \ xform[2][0], xform[2][1], xform[2][2], xform[2][3] ); A = nifti_mat44_inverse(A0); UNLOAD_MAT44(A, \ xform[0][0], xform[0][1], xform[0][2], xform[0][3], \ xform[1][0], xform[1][1], xform[1][2], xform[1][3], \ xform[2][0], xform[2][1], xform[2][2], xform[2][3] ); } if (Do_PolDec) { #ifdef USE_DECOMPOSE_SHOEMAKE /* a little something to do a polar decomposition on M into M = Q*S*/ { float det, m[4][4], q[4][4], s[4][4]; char *stmp = SUMA_append_string("QS_",xmat_name); FILE *fout = fopen(stmp,"w"); SUMA_free(stmp); stmp = NULL; SUMA_S_Note("FixMe! #include above and if(1) here ..."); det = polar_decomp(M, q,s); fprintf(fout,"#[M][D]: (D is the shift)\n"); for (i=0;i<3; ++i) fprintf(fout, "#%.5f %.5f %.5f %.5f\n", M[i][0], M[i][1], M[i][2], M[i][3]); fprintf(fout,"#Q:\n"); for (i=0;i<3; ++i) fprintf(fout, "#%.5f %.5f %.5f %.5f\n", q[i][0], q[i][1], q[i][2], q[i][3]); fprintf(fout,"#S:\n"); for (i=0;i<3; ++i) fprintf(fout, "#%.5f %.5f %.5f %.5f\n", s[i][0], s[i][1], s[i][2], s[i][3]); fprintf(fout,"#det: %f\n", det); fprintf(fout, "#[Q][D]: A close xform to [M][D], " "without scaling.\n#M = Q*S\n"); for (i=0;i<3; ++i) fprintf(fout, "%.5f %.5f %.5f %.5f\n", q[i][0], q[i][1], q[i][2], M[i][3]); fclose(fout); SUMA_free(stmp); stmp = NULL; } /* replace user's xform with orthogonal one: */ fprintf(SUMA_STDOUT,"Replacing matrix:\n"); for (i=0;i<3; ++i) fprintf( SUMA_STDOUT, " %.5f %.5f %.5f %.5f\n", M[i][0], M[i][1], M[i][2], M[i][3]); fprintf(SUMA_STDOUT," with matrix:\n"); for (i=0;i<3; ++i) fprintf(SUMA_STDOUT, " %.5f %.5f %.5f %.5f\n", q[i][0], q[i][1], q[i][2], M[i][3]); for (i=0;i<3; ++i) { M[i][0] = q[i][0]; M[i][1] = q[i][1]; M[i][2] = q[i][2]; } #else {/* use the NIFTI polar decomposition function (same results as above)*/ mat33 Q, A; for (i=0;i<3;++i) { A.m[i][0] = xform[i][0]; A.m[i][1] = xform[i][1]; A.m[i][2] = xform[i][2]; } Q = nifti_mat33_polar( A ); /* replace user's xform with orthogonal one: */ fprintf(SUMA_STDOUT,"Replacing matrix:\n"); for (i=0;i<3; ++i) fprintf( SUMA_STDOUT, " %.5f %.5f %.5f %.5f\n", xform[i][0], xform[i][1], xform[i][2], xform[i][3]); fprintf(SUMA_STDOUT," with matrix:\n"); for (i=0;i<3; ++i) fprintf( SUMA_STDOUT, " %.5f %.5f %.5f %.5f\n", Q.m[i][0], Q.m[i][1], Q.m[i][2], xform[i][3]); for (i=0;i<3; ++i) { xform[i][0] = Q.m[i][0]; xform[i][1] = Q.m[i][1]; xform[i][2] = Q.m[i][2]; } } #endif } } if ( ps->i_N_surfnames == 1) { /* load that one surface */ SO = SUMA_Load_Surface_Object_Wrapper ( if_name, if_name2, vp_name, iType, iForm, sv_name, 1); if (!SO) { SUMA_S_Err("Failed to read input surface.\n"); exit (1); } } else if ( ps->i_N_surfnames > 1 && Domergesurfs) { SUMA_SurfaceObject **SOar=NULL; int ii; SUMA_S_Notev("Merging %d surfaces into 1\n", ps->i_N_surfnames); SOar = (SUMA_SurfaceObject **) SUMA_calloc(ps->i_N_surfnames, sizeof(SUMA_SurfaceObject *)); if (ps->N_sv > 1 || ps->N_vp > 1) { SUMA_S_Errv("Cannot handle multiple (%d) -sv or multiple (%d) -vp\n", ps->N_sv, ps->N_vp); exit(1); } for (ii = 0; ii<ps->i_N_surfnames; ++ii) { SOar[ii] = SUMA_Load_Surface_Object_Wrapper(ps->i_surfnames[ii], ps->i_surftopo[ii], vp_name, ps->i_FT[0], ps->i_FF[0], sv_name, 1); } if (!(SO = SUMA_MergeSurfs(SOar, ps->i_N_surfnames))) { SUMA_S_Err("Failed to merge"); exit(1); } for (ii = 0; ii<ps->i_N_surfnames; ++ii) { SUMA_Free_Surface_Object(SOar[ii]); SOar[ii]=NULL; } SUMA_free(SOar); SOar=NULL; } if (DoR2S > 0.0000001) { if (!SUMA_ProjectSurfaceToSphere(SO, NULL , DoR2S , NULL)) { SUMA_S_Err("Failed to project to surface"); exit(1); } } if (ifpar_name) { SOpar = SUMA_Load_Surface_Object_Wrapper ( ifpar_name, ifpar_name2, vp_name, iparType, iparForm, sv_name, 1); if (!SOpar) { SUMA_S_Err("Failed to read input parent surface.\n"); exit (1); } /* need edge list */ if (!SUMA_SurfaceMetrics_eng (SOpar,"EdgeList", NULL, 0, SUMAg_CF->DsetList)) { SUMA_SL_Err("Failed to create edgelist for parent"); exit(1); } } /* if Do_wind */ if (Do_wind) { fprintf (SUMA_STDOUT, "Checking and repairing mesh's winding consistency...\n"); /* check the winding, but that won't fix the normals, you'll have to recalculate those things, if need be ... */ if (!SUMA_SurfaceMetrics_eng (SO, "CheckWind", NULL, 0, SUMAg_CF->DsetList)) { SUMA_S_Err("Failed in SUMA_SurfaceMetrics.\n"); exit(1); } } if (Do_flip) { fprintf (SUMA_STDOUT, "Flipping triangle winding...\n"); SUMA_FlipSOTriangles(SO); } if (Do_tlrc) { fprintf (SUMA_STDOUT,"Performing talairach transform...\n"); /* form the tlrc version of the surface volume */ tlrc_name = (char *) SUMA_calloc (strlen(SO->VolPar->dirname)+ strlen(SO->VolPar->prefix)+60, sizeof(char)); sprintf (tlrc_name, "%s%s+tlrc.HEAD", SO->VolPar->dirname, SO->VolPar->prefix); if (!SUMA_filexists(tlrc_name)) { fprintf (SUMA_STDERR,"Error %s: %s not found.\n", FuncName, tlrc_name); exit(1); } /* read the tlrc header */ aset = THD_open_dataset(tlrc_name) ; if( !ISVALID_DSET(aset) ){ SUMA_S_Err("%s is not a valid data set.\n", tlrc_name) ; exit(1); } if( aset->warp == NULL ){ SUMA_S_Err("tlrc_name does not contain a talairach transform.\n"); exit(1); } warp = aset->warp ; /* now warp the coordinates, one node at a time */ if (!SUMA_AFNI_forward_warp_xyz(warp, SO->NodeList, SO->N_Node)) { SUMA_S_Err("Failed in SUMA_AFNI_forward_warp_xyz.\n"); exit(1); } } if (Do_acpc) { fprintf (SUMA_STDOUT,"Performing acpc transform...\n"); /* form the acpc version of the surface volume */ acpc_name = (char *) SUMA_calloc (strlen(SO->VolPar->dirname)+ strlen(SO->VolPar->prefix)+60, sizeof(char)); sprintf (acpc_name, "%s%s+acpc.HEAD", SO->VolPar->dirname, SO->VolPar->prefix); if (!SUMA_filexists(acpc_name)) { fprintf (SUMA_STDERR,"Error %s: %s not found.\n", FuncName, acpc_name); exit(1); } /* read the acpc header */ aset = THD_open_dataset(acpc_name) ; if( !ISVALID_DSET(aset) ){ fprintf (SUMA_STDERR, "Error %s: %s is not a valid data set.\n", FuncName, acpc_name) ; exit(1); } if( aset->warp == NULL ){ fprintf (SUMA_STDERR, "Error %s: acpc_name does not contain an acpc transform.\n", FuncName); exit(1); } warp = aset->warp ; /* now warp the coordinates, one node at a time */ if (!SUMA_AFNI_forward_warp_xyz(warp, SO->NodeList, SO->N_Node)) { fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_AFNI_forward_warp_xyz.\n", FuncName); exit(1); } } if (Do_mni_RAI) { fprintf (SUMA_STDOUT,"Performing MNI_RAI transform...\n"); /* apply the mni warp */ if (!SUMA_AFNItlrc_toMNI(SO->NodeList, SO->N_Node, "RAI")) { fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_AFNItlrc_toMNI.\n", FuncName); exit(1); } sprintf(orsurf,"RAI"); } if (Do_mni_LPI) { fprintf (SUMA_STDOUT,"Performing MNI_LPI transform...\n"); /* apply the mni warp */ if (!SUMA_AFNItlrc_toMNI(SO->NodeList, SO->N_Node, "LPI")) { fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_AFNItlrc_toMNI.\n", FuncName); exit(1); } sprintf(orsurf,"LPI"); } if (Doxmat) { fprintf (SUMA_STDOUT,"Performing affine transform...\n"); if (LocalHead) { for (i=0; i<3 ; ++i) { fprintf (SUMA_STDERR, "M[%d][:] = %f %f %f %f\n", i, xform[i][0], xform[i][1], xform[i][2], xform[i][3]); } fprintf (SUMA_STDERR,"Cen[:] %f %f %f\n", xcen[0], xcen[1], xcen[2]); } if (Docen) { if (!SUMA_Apply_Coord_xform( SO->NodeList, SO->N_Node, SO->NodeDim, xform, 0, xcen)) { SUMA_SL_Err("Failed to xform coordinates"); exit(1); } } else { if (!SUMA_Apply_Coord_xform( SO->NodeList, SO->N_Node, SO->NodeDim, xform, 0, NULL)) { SUMA_SL_Err("Failed to xform coordinates"); exit(1); } } SUMA_Blank_AfniSO_Coord_System(SO->aSO); } if (orcode[0] != '\0') { SUMA_LHv("Changing coordinates from %s to %s\n", orsurf, orcode); if (!SUMA_CoordChange(orsurf, orcode, SO->NodeList, SO->N_Node)) { SUMA_S_Err("Failed to change coords."); exit(1); } SUMA_Blank_AfniSO_Coord_System(SO->aSO); } if (Do_p2s) { SUMA_SurfaceObject *SOold = SO; SUMA_LH("Changing patch to surface..."); SO = SUMA_Patch2Surf(SOold->NodeList, SOold->N_Node, SO->FaceSetList, SO->N_FaceSet, 3); if (!SO) { SUMA_S_Err("Failed to change patch to surface."); exit(1); } /* get rid of old surface object */ SUMA_Free_Surface_Object(SOold); } if (Do_native) { if (!SUMA_Delign_to_VolPar (SO, NULL)) { SUMA_S_Err("Failed to transform coordinates to native space"); exit(1); } } if (Do_NodeDepth) { float *dpth=NULL, mx=0.0; SUMA_PC_XYZ_PROJ *pcp=NULL; if (SUMA_NodeDepth(SO->NodeList, SO->N_Node, E1_DIR_PRJ, &dpth, 0.0, NULL, &mx, &pcp) < 0) { SUMA_S_Err("Failed to compute node depth"); exit(1); } else { if (!SUMA_WriteNodeDepth(NodeDepthpref,pcp,dpth, mx)) { SUMA_S_Err("Failed to write node depth"); exit(1); } } SUMA_ifree(dpth); pcp = SUMA_Free_PC_XYZ_Proj(pcp); } if (Do_PCproj > NO_PRJ) { SUMA_PC_XYZ_PROJ *pcp=NULL; pciref = 0; pcxyzref = NULL; if (!(pcp = SUMA_Project_Coords_PCA(SO->NodeList, SO->N_Node, pciref, pcxyzref, Do_PCproj, Do_PCrot, 1))) { SUMA_S_Err("Failed to project"); exit(1); } else { if (!SUMA_Write_PC_XYZ_Proj(pcp, PCprojpref)) { SUMA_S_Err("Failed to write out projections"); exit(1); } else { pcp = SUMA_Free_PC_XYZ_Proj(pcp); } exit(0); } } /* write the surface object */ if (SO_name) { if (LocalHead) SUMA_Print_Surface_Object (SO, stderr); fprintf (SUMA_STDOUT,"Writing surface...\n"); if (!(SUMA_Save_Surface_Object ( SO_name, SO, oType, oFormat, SOpar))) { fprintf (SUMA_STDERR, "Error %s: Failed to write surface object.\n", FuncName); exit (1); } } if (of_name_strip) of_name_strip = SUMA_Free_Parsed_Name (of_name_strip); if (of_name2_strip) of_name2_strip = SUMA_Free_Parsed_Name (of_name2_strip); if (OF_name) SUMA_free(OF_name); if (OF_name2) SUMA_free(OF_name2); if (SF_name) SUMA_free(SF_name); if (SO_name) SUMA_free(SO_name); if (SO) SUMA_Free_Surface_Object(SO); if (SOpar) SUMA_Free_Surface_Object(SOpar); if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL; return (0); }