int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"SurfMatch"};
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_SurfSpecFile *Spec = NULL;
int N_Spec=0, N_inmask;
byte *cmask=NULL;
SUMA_SurfaceObject *SO = NULL, *SOr=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;");
if (argc < 2) {
usage_SurfMatch(ps, 0);
exit (1);
}
Opt = SUMA_SurfMatch_ParseInput (argv, argc, ps);
if (Opt->debug > 2) LocalHead = YUP;
/* check on inputs */
if (ps->s_N_surfnames + ps->i_N_surfnames + ps->t_N_surfnames != 2) {
SUMA_S_Err("Must have two surfaces");
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);
}
SOr = SUMA_Load_Spec_Surf_with_Metrics(Spec, 0, ps->sv[0], 1);
if (!SOr) {
fprintf (SUMA_STDERR,"Error %s:\n"
"Failed to find surface\n"
"in spec file. \n",
FuncName );
exit(1);
}
if (Opt->efrac>0.0) {
SUMA_SurfaceObject *SOrr=NULL;
if (!(SOrr = SUMA_Mesh_Resample_nodes(SOr, Opt->efrac))) {
SUMA_S_Errv("Failed to resample initial mesh at %f\n",Opt->efrac);
exit(1);
}
SUMA_Free_Surface_Object(SOr); SOr=SOrr; SOrr=NULL;
SUMA_SurfaceMetrics_eng(SOr, "EdgeList|MemberFace", NULL, 0,
SUMAg_CF->DsetList);
if (!SOr->Label && !(SUMA_SurfaceFileName(SOr, NOPE))) {
SOr->Label = SUMA_copy_string("Le_Remaille");
}
}
SO = SUMA_Load_Spec_Surf_with_Metrics(Spec, 1, ps->sv[0], 1);
if (Opt->flt1 != 1.0) {
SUMA_LHv("Masking out nodes deeper than %f mm", Opt->flt1);
N_inmask = SUMA_NodeDepth(SO->NodeList, SO->N_Node, prjdir, NULL,
Opt->flt1, &cmask, NULL);
} else {
N_inmask = SO->N_Node;
}
SUMA_S_Notev("Have Reference %s %d nodes, input %s, %d nodes (%d in mask)\n",
SOr->Label, SOr->N_Node, SO->Label, SO->N_Node, N_inmask);
if (Opt->b1) {
Opt->s = SUMA_append_replace_string(Opt->s,"City", " ; ", 1);
}
SUMA_AlignCoords(SO->NodeList, SO->N_Node, cmask, 1, SOr, Opt->s);
/* write surface */
if (!SUMA_Save_Surface_Object_Wrap (Opt->out_prefix, NULL, SO,
SUMA_FT_NOT_SPECIFIED, SUMA_FF_NOT_SPECIFIED,
NULL)) {
SUMA_S_Err("Failed to write surface of whole head");
exit (1);
}
if (SOr) SUMA_Free_Surface_Object(SOr); SOr = NULL;
if (SO) SUMA_Free_Surface_Object(SO); SO = NULL;
if (cmask) SUMA_free(cmask); cmask=NULL;
if (ps) SUMA_FreeGenericArgParse(ps); ps = 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 (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_Boolean SUMA_bool_eval_truth_table(char *dexpr, byte use_orig)
{
static char FuncName[]={"SUMA_bool_eval_truth_table"};
int n, ivar, k, N_used, N_rows, stp, block;
byte used[26], ee;
char these[26], **allexp=NULL, **allvars=NULL,
allv[26*2+1], expr[1024], tight[1024];
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
if (!dexpr || strlen(dexpr)>512) {
SUMA_S_Err("NULL expression or too long a string");
SUMA_RETURN(NOPE);
}
if (!use_orig) {
SUMA_DispExpr_To_EvalExpr(dexpr, expr, tight);
} else {
strcpy(expr, dexpr);
}
memset(used,0, sizeof(byte)*26);
N_used = 0;
k = 0;
while (expr[k]!='\0') {
ivar = expr[k] - 'a';
if (ivar >= 0 && ivar <= 26) {
if (!used[ivar]) {
these[N_used] = expr[k];
++N_used;
used[ivar] = 1;
}
}
++k;
}
for (k=0; k<N_used; ++k) {
allv[2*k] = these[k];
allv[2*k+1] = ' ';
}
allv[2*N_used] = '\0';
/* preallocate for all outcomes */
N_rows = pow(2,N_used);
allexp = (char **)SUMA_calloc(N_rows,sizeof(char *));
for (k=0; k<N_rows; ++k) allexp[k] = SUMA_copy_string(expr);
allvars = (char **)SUMA_calloc(N_rows,sizeof(char *));
for (k=0; k<N_rows; ++k) allvars[k] = SUMA_copy_string(allv);
for (k=0; k<N_used; ++k) { /* which var to replace */
stp = pow(2,k);
block = 0;
if (LocalHead)
fprintf(stderr,"k=%d, N_used = %d, stp=%d\n",
k, N_used, stp);
for (n=0; n<N_rows; ++n) {
if (!(n%(2*stp))) ++block;
if (n < 2*stp*block-stp) {
SUMA_set_bool_var_in_expr(allexp[n], these[N_used-k-1], 0);
SUMA_set_bool_var_in_expr(allvars[n], these[N_used-k-1], 0);
} else {
SUMA_set_bool_var_in_expr(allexp[n], these[N_used-k-1], 1);
SUMA_set_bool_var_in_expr(allvars[n], these[N_used-k-1], 1);
}
if (LocalHead)
fprintf(stderr,"n=%d, block=%d (%d): %s\n",
n, block, (int)(pow(2,stp)*block), allexp[n]);
}
}
/* show expressions */
fprintf(SUMA_STDERR,"Truth Table for %s:\n", dexpr);
fprintf(SUMA_STDERR,"%s: %s = ?\n", allv, expr);
fprintf(SUMA_STDERR,"----------------\n");
for (n=0; n<N_rows; ++n) {
SUMA_bool_eval(allexp[n], &ee);
fprintf(SUMA_STDERR,"%s: %s = %d\n", allvars[n], allexp[n], ee);
}
/* clear */
for (n=0; n<N_rows; ++n) SUMA_ifree(allexp[n]);
SUMA_ifree(allexp);
for (n=0; n<N_rows; ++n) SUMA_ifree(allvars[n]);
SUMA_ifree(allvars);
SUMA_RETURN(YUP);
}
SUMA_Boolean SUMA_bool_mask_eval(int N_vals, int N_vars, byte **mask, char *expr,
byte *res, byte *varcol, byte *rescol,
char **resstr)
{
static char FuncName[]={"SUMA_bool_mask_eval"};
char *extmp=NULL;
int i=0, k, A, R, G, B, ivar, n;
float sc, x;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
if (N_vars != 26) {
SUMA_S_Err("mask must be an array of 26 byte * pointers");
SUMA_RETURN(NOPE);
}
if (!res) {
SUMA_S_Err("Need return pointer");
SUMA_RETURN(NOPE);
}
if ((rescol && !varcol)) {
SUMA_S_Err("Need rescol for varcol");
SUMA_RETURN(NOPE);
}
if (resstr && !rescol) {
SUMA_S_Err("resstr not good without rescol");
SUMA_RETURN(NOPE);
}
extmp = SUMA_copy_string(expr);
for (i=0; i < N_vals; ++i) {
/* create the expression */
k = 0;
while (expr[k]!='\0') {
ivar = expr[k] - 'a';
if (ivar >= 0 && ivar <= 26) {
if (IN_MASK(mask[ivar], i)) extmp[k] = '1';
else extmp[k] = '0';
}
++k;
}
/* evaluate */
SUMA_bool_eval(extmp, res+i);
#if EVAL_DBG
SUMA_LH("%s = %d", extmp, res[i]);
#endif
}
SUMA_ifree(extmp);
if (rescol) {
for (i=0; i < N_vals; ++i) {
if (res[i]) {/* We need that one, blend the colors */
A = R = G = B = n = 0;
k = 0;
while (expr[k]!='\0') {
ivar = expr[k] - 'a';
if (ivar >= 0 && ivar <= 26) {
if (IN_MASK(mask[ivar], i)) {
R += varcol[4*ivar+0]*varcol[4*ivar+3];
G += varcol[4*ivar+1]*varcol[4*ivar+3];
B += varcol[4*ivar+2]*varcol[4*ivar+3];
A += varcol[4*ivar+3];
if (resstr) resstr[i][n]=expr[k];
n++;
}
}
++k;
}
if (resstr) resstr[i][n]='\0';
sc = A/(float)n; /* Consider an additional dimming factor from sv->*/
if ((x=R/sc) > 255) rescol[4*i ] = 255;
else rescol[4*i ] = (byte)x;
if ((x=G/sc) > 255) rescol[4*i+1] = 255;
else rescol[4*i+1] = (byte)x;
if ((x=B/sc) > 255) rescol[4*i+2]=255;
else rescol[4*i+2] = (byte)x;
if ( sc > 255) rescol[4*i+3]=255;
else rescol[4*i+3] = (byte)sc;
} else {
rescol[4*i ] = 128;
rescol[4*i+1] = 128;
rescol[4*i+2] = 128;
rescol[4*i+3] = 0;
if (resstr) resstr[i][0]='\0';
}
#if EVAL_DBG
SUMA_LH("Color at %d: %-3d %-3d %-3d %-3d\n",
i, rescol[4*i ], rescol[4*i+1], rescol[4*i+2], rescol[4*i+3]);
#endif
}
}
SUMA_RETURN(YUP);
}
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);
}
/*!
A toy function to identify windows on the root window.
This function can potentially be used to identify where
AFNI windows, for example, are taking screen space and
have SUMA avoid overlapping with them.
The function needs much work. It is not terribly selective
about what it chases down.
See command line xwininfo -tree -root
for full listing from command line, or xwininfo for
interactive queries.
For now, we let this rest.
*/
int SUMA_WindowsOnRootDisplay(Display *dd, Window ww, int all)
{
static char FuncName[]={"SUMA_WindowsOnRootDisplay"};
Window rr, pr, *cr, jj;
XWindowAttributes wa;
unsigned int ncr, wr, hr, bwr, bhr;
int ii, xr, yr, showgeom=0;
char *wname=NULL, *sout=NULL;
/* tell me what windows are displayed and where */
if (XQueryTree(dd,
ww,
&rr, &pr, &cr, &ncr)) {
if (all) fprintf(stderr,"Have %d childern in query\n", ncr);
for (ii=0; ii<ncr; ++ii) {
showgeom = 0;
XGetWindowAttributes(dd, cr[ii], &wa);
XTranslateCoordinates (dd, cr[ii], wa.root,
-wa.border_width,
-wa.border_width,
&xr, &yr, &jj);
if (XFetchName(dd, cr[ii], &wname)) {
/* XGetWMName usage From source of xwininfo.c,
Not getting advantage over XFetchName for
lots more hassle ....*/
if (wname) {
sout = SUMA_copy_string(wname);
XFree(wname);
} else sout = SUMA_copy_string("no name but fetch OK!");
if (strcasestr(sout,"afni") ||
strcasestr(sout,"suma") ) {
fprintf(stderr," brethren %d: %s\n", ii, sout);
showgeom=1;
} else {
if (all) {
fprintf(stderr," furner %d: %s\n", ii, sout);
showgeom=1;
}
}
} else {
if (all) {
fprintf(stderr," %d: (No name!)\n", ii);
showgeom = 1;
}
}
if (showgeom) {
fprintf(stderr,
" abs Upper Left X Y %d %d, (rel UL %d %d) W H%d %d, \n",
xr, yr, wa.x, wa.y, wa.width, wa.height);
/*
Under alternative below, xr and yr are relative UL vals */
#if 0
if (XGetGeometry(dd, cr[ii], &rr,
&xr, &yr, &wr, &hr, &bwr, &bhr)) {
fprintf(stderr," %d %d, %dx%d, %d %d\n",
xr, yr, wr, hr, bwr, bhr);
}
#endif
}
if (sout) SUMA_free(sout); sout = NULL;
SUMA_WindowsOnRootDisplay(dd, cr[ii],all);
}
}
}
SUMA_GENERIC_PROG_OPTIONS_STRUCT *
SUMA_SpharmReco_ParseInput(char *argv[], int argc,
SUMA_GENERIC_ARGV_PARSE *ps)
{
static char FuncName[]={"SUMA_SpharmReco_ParseInput"};
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt=NULL;
int kar;
SUMA_Boolean brk;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
Opt = SUMA_Alloc_Generic_Prog_Options_Struct();
Opt->iopt = 86;
Opt->out_prefix = NULL;
Opt->bases_prefix = NULL;
Opt->unit_sphere_name = NULL;
Opt->n_in_namev = 0;
Opt->v0 = 0.0001;
kar = 1;
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_SpharmReco(ps);
exit (0);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
if (!brk && (strcmp(argv[kar], "-coef") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need an prefix after -coef \n");
exit (1);
}
Opt->in_namev[Opt->n_in_namev++] = argv[++kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-l") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need an integer after -l \n");
exit (1);
}
Opt->iopt = atoi(argv[++kar]);
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_copy_string(argv[++kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-bases_prefix") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a name after -bases_prefix\n");
exit (1);
}
Opt->bases_prefix = argv[++kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-bases") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a name after -bases\n");
exit (1);
}
Opt->bases_prefix = argv[++kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-unit_sph") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a name after -unit_sph\n");
exit (1);
}
Opt->unit_sphere_name = argv[++kar];
brk = YUP;
}
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], "-sigma") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a number after -sigma \n");
exit (1);
}
Opt->v0 = atof(argv[++kar]);
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]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}
SUMA_RETURN(Opt);
}
/*!
\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 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[]= {"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);
}
/*!
\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);
}
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);
}
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 */
/*!
\brief parse the arguments for SurfSmooth program
\param argv (char *)
\param argc (int)
\return Opt (SUMA_GENERIC_PROG_OPTIONS_STRUCT *) options structure.
To free it, use
SUMA_free(Opt->out_name);
SUMA_free(Opt);
*/
SUMA_GENERIC_PROG_OPTIONS_STRUCT *SUMA_ConvexHull_ParseInput (char *argv[], int argc, SUMA_GENERIC_ARGV_PARSE *ps)
{
static char FuncName[]={"SUMA_ConvexHull_ParseInput"};
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt=NULL;
int kar, i, ind;
char *outname;
SUMA_Boolean brk = NOPE;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
Opt = (SUMA_GENERIC_PROG_OPTIONS_STRUCT *)SUMA_malloc(sizeof(SUMA_GENERIC_PROG_OPTIONS_STRUCT));
kar = 1;
Opt->spec_file = NULL;
Opt->out_prefix = NULL;
Opt->sv_name = NULL;
Opt->N_surf = -1;
Opt->in_name = NULL;
Opt->cmask = NULL;
Opt->MaskMode = SUMA_ISO_UNDEFINED;
for (i=0; i<SUMA_GENERIC_PROG_MAX_SURF; ++i) { Opt->surf_names[i] = NULL; }
outname = NULL;
Opt->in_vol = NULL;
Opt->nvox = -1;
Opt->ninmask = -1;
Opt->mcdatav = NULL;
Opt->debug = 0;
Opt->v0 = 0.0;
Opt->v1 = -1.0;
Opt->fvec = NULL;
Opt->SurfFileType = SUMA_PLY;
Opt->SurfFileFormat = SUMA_ASCII;
Opt->xform = SUMA_ISO_XFORM_MASK;
Opt->obj_type = -1;
Opt->obj_type_res = -1;
Opt->XYZ = NULL;
Opt->in_1D = NULL;
Opt->N_XYZ = 0;
Opt->s = SUMA_copy_string("convex_hull");
Opt->geom = 1;
Opt->corder = 0;
Opt->unif = 0;
Opt->UseThisBrain = NULL;
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_ConvexHull(ps);
exit (0);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
if (!brk && (strcmp(argv[kar], "-xform") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -xform \n");
exit (1);
}
if (!strcmp(argv[kar], "mask")) {
Opt->xform = SUMA_ISO_XFORM_MASK;
} else if (!strcmp(argv[kar], "none")) {
Opt->xform = SUMA_ISO_XFORM_NONE;
} else if (!strcmp(argv[kar], "shift")) {
Opt->xform = SUMA_ISO_XFORM_SHIFT;
}else {
fprintf (SUMA_STDERR,
"%s is a bad parameter for -xform option. \n", argv[kar]);
exit (1);
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-input_1D") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -input_1D \n");
exit (1);
}
Opt->in_1D = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-these_coords") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -these_coords \n");
exit (1);
}
Opt->UseThisBrain = argv[kar];
Opt->unif = 2;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-q_opt") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need option after -q_opt \n");
exit (1);
}
if (!strcmp(argv[kar],"triangulate_xy")) {
Opt->geom = 2;
} else if (!strcmp(argv[kar],"convex_hull")) {
Opt->geom = 1;
} else {
SUMA_S_Errv("Bad value of %s for -q_opt", argv[kar]);
exit(1);
}
Opt->s = SUMA_copy_string(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-proj_xy") == 0)) {
Opt->corder = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-orig_coord") == 0)) {
Opt->unif = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-debug") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -debug \n");
exit (1);
}
Opt->debug = atoi(argv[kar]);
if (Opt->debug > 2) { LocalHead = YUP; }
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-isocmask") == 0)) {
if (Opt->MaskMode != SUMA_ISO_UNDEFINED) {
fprintf (SUMA_STDERR, "only one masking mode (-iso*) allowed.\n");
}
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -isocmask \n");
exit (1);
}
Opt->cmask = argv[kar];
Opt->MaskMode = SUMA_ISO_CMASK;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-isoval") == 0)) {
if (Opt->MaskMode != SUMA_ISO_UNDEFINED) {
fprintf (SUMA_STDERR, "only one masking mode (-iso*) allowed.\n");
}
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -isoval \n");
exit (1);
}
Opt->v0 = atof(argv[kar]);
Opt->MaskMode = SUMA_ISO_VAL;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-isorange") == 0)) {
if (Opt->MaskMode != SUMA_ISO_UNDEFINED) {
fprintf (SUMA_STDERR, "only one masking mode (-iso*) allowed.\n");
}
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need 2 arguments after -isorange \n");
exit (1);
}
Opt->v0 = atof(argv[kar]);kar ++;
Opt->v1 = atof(argv[kar]);
Opt->MaskMode = SUMA_ISO_RANGE;
if (Opt->v1 < Opt->v0) {
fprintf (SUMA_STDERR,
"range values wrong. Must have %f <= %f \n",
Opt->v0, Opt->v1);
exit (1);
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-input") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -input \n");
exit (1);
}
Opt->in_name = SUMA_copy_string(argv[kar]);
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]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}
/* transfer some options to Opt from ps.
Clunky because this is retrofitting */
if (ps->o_N_surfnames) {
Opt->out_prefix = SUMA_copy_string(ps->o_surfnames[0]);
Opt->SurfFileType = ps->o_FT[0];
Opt->SurfFileFormat = ps->o_FF[0];
}
if (ps->i_N_surfnames) {
if (Opt->in_name || Opt->in_1D) {
SUMA_S_Err( "Options -i_TYPE, -input and -input_1D"
" are mutually exclusive.");
exit(1);
}
}
if (Opt->in_name) {
if (ps->i_N_surfnames !=0 || Opt->in_1D) {
fprintf (SUMA_STDERR,"Error %s:\nOptions -i_TYPE, -input and -input_1D are mutually exclusive.\n", FuncName);
exit(1);
}
}
if (Opt->in_1D) {
if (ps->i_N_surfnames !=0 || Opt->in_name) {
fprintf (SUMA_STDERR,"Error %s:\nOptions -i_TYPE, -input and -input_1D are mutually exclusive.\n", FuncName);
exit(1);
}
}
if (Opt->in_name && Opt->obj_type >= 0) {
fprintf (SUMA_STDERR,"Error %s:\nOptions -input and -shape are mutually exclusive.\n", FuncName);
exit(1);
}
if ((!Opt->in_name && Opt->obj_type < 0) && (!Opt->in_1D && !ps->i_N_surfnames)) {
fprintf (SUMA_STDERR,"Error %s:\nEither -input or -input_1D or -i_TYPE options must be used.\n", FuncName);
exit(1);
}
if (Opt->in_1D || ps->i_N_surfnames) {
if (Opt->MaskMode != SUMA_ISO_UNDEFINED) {
fprintf (SUMA_STDERR,"Error %s:\nCannot use -iso* options with either -input_1D or -i_TYPE options.\n", FuncName);
exit(1);
}
if (Opt->xform != SUMA_ISO_XFORM_MASK) {
fprintf (SUMA_STDERR,"Error %s:\nCannot use -xform option with either -input_1D or -i_TYPE options.\n", FuncName);
exit(1);
}
}
if (!Opt->out_prefix) Opt->out_prefix = SUMA_copy_string("convexhull_out");
if (Opt->xform == SUMA_ISO_XFORM_NONE) {
if (Opt->v0 != 0) {
fprintf (SUMA_STDERR,"Error %s: Bad %f isovalue\nWith -xform none you can only extract the 0 isosurface.\n(i.e. -isoval 0)\n", FuncName, Opt->v0);
exit(1);
}
if (Opt->MaskMode != SUMA_ISO_VAL) {
fprintf (SUMA_STDERR,"Error %s: \nWith -xform none you can only use -isoval 0\n", FuncName);
exit(1);
}
}
if (Opt->xform == SUMA_ISO_XFORM_SHIFT) {
if (Opt->MaskMode != SUMA_ISO_VAL) {
fprintf (SUMA_STDERR,"Error %s: \nWith -xform shift you can only use -isoval val\n", FuncName);
exit(1);
}
}
SUMA_RETURN(Opt);
}
SEG_OPTS *Seg_ParseInput (SEG_OPTS *Opt, char *argv[], int argc)
{
static char FuncName[]={"Seg_ParseInput"};
int kar, i, ind, exists;
char *outname, cview[10];
int brk = 0;
ENTRY("Seg_ParseInput");
brk = 0;
kar = 1;
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) {
Opt->helpfunc(0);
exit (0);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
#ifdef USE_TRACING
if( strncmp(argv[kar],"-trace",5) == 0 ){
DBG_trace = 1 ;
brk = 1 ;
}
if( strncmp(argv[kar],"-TRACE",5) == 0 ){
DBG_trace = 2 ;
brk = 1 ;
}
#endif
if (!brk && (strcmp(argv[kar], "-debug") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -debug \n");
exit (1);
}
Opt->debug = atoi(argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-talk_afni") == 0)) {
Opt->ps->cs->talk_suma = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-do") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -do \n");
exit (1);
}
if (strchr(argv[kar], 'c')) Opt->DO_c = 1;
if (strchr(argv[kar], 'f')) Opt->DO_f = 1;
if (strchr(argv[kar], 'x')) Opt->DO_x = 1;
if (strchr(argv[kar], 'p')) Opt->DO_p = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-L2") == 0)) {
Opt->fitmeth = SEG_LSQFIT;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-L1") == 0)) {
Opt->fitmeth = SEG_L1FIT;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-openmp") == 0)) {
Opt->openmp = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-no_openmp") == 0)) {
Opt->openmp = 0;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-pweight") == 0)) {
Opt->pweight = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-no_pweight") == 0)) {
Opt->pweight = 0;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-no_edge") == 0)) {
Opt->edge = 0;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-edge") == 0)) {
Opt->edge = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-edge1") == 0)) {
Opt->edge = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-edge2") == 0)) {
Opt->edge = 2;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-vox_debug") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need 1D vox index after -vox_debug \n");
exit (1);
}
if (kar+2<argc) { /* see if we have ijk */
int iii, jjj, kkk;
if ( argv[kar ][0]!='-' &&
argv[kar+1][0]!='-' &&
argv[kar+2][0]!='-' &&
(iii = atoi(argv[kar ])) >= 0 &&
(jjj = atoi(argv[kar+1])) >= 0 &&
(kkk = atoi(argv[kar+2])) >= 0 ) {
Opt->VoxDbg3[0]=iii;
Opt->VoxDbg3[1]=jjj;
Opt->VoxDbg3[2]=kkk;
++kar; ++kar;
}
}
if (Opt->VoxDbg3[0] < 0) {
Opt->VoxDbg = atoi(argv[kar]);
}
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-vox_debug_file") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need filename after -vox_debug_file \n");
exit (1);
}
if (!strcmp(argv[kar],"-")) {
Opt->VoxDbgOut = stdout;
} else if (!strcmp(argv[kar],"+")) {
Opt->VoxDbgOut = stderr;
} else {
Opt->VoxDbgOut = fopen(argv[kar],"w");
}
brk = 1;
}
if (strcmp(argv[kar],"-logp") == 0 ) {
Opt->logp = 1;
brk = 1;
}
if (strcmp(argv[kar],"-p") == 0 ) {
Opt->logp = 0;
brk = 1;
}
if( strcmp(argv[kar],"-use_tmp") == 0 ){
Opt->UseTmp = 1 ;
brk = 1;
}
if( strcmp(argv[kar],"-no_tmp") == 0 ){
Opt->UseTmp = 0 ;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-vox_debug") == 0)) {
kar ++;
if (kar+2 >= argc) {
fprintf (stderr, "need 3 arguments after -vox_debug \n");
exit (1);
}
Opt->idbg = atoi(argv[kar]); ++kar;
Opt->jdbg = atoi(argv[kar]); ++kar;
Opt->kdbg = atoi(argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-cmask") == 0)) {
kar ++;
if (kar >= argc) {
ERROR_exit("-cmask option requires a following argument!\n");
}
Opt->cmask = EDT_calcmask( argv[kar] , &(Opt->dimcmask), 0 ) ;
if( Opt->cmask == NULL ) ERROR_exit("Can't compute -cmask!\n");
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-mask") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -mask \n");
exit (1);
}
Opt->mset_name = argv[kar];
brk = 1;
}
if( !brk && (strncmp(argv[kar],"-mrange",5) == 0) ){
if( kar+2 >= argc )
ERROR_exit("-mrange option requires 2 following arguments!\n");
Opt->mask_bot = strtod( argv[++kar] , NULL ) ;
Opt->mask_top = strtod( argv[++kar] , NULL ) ;
if( Opt->mask_top < Opt->mask_bot )
ERROR_exit("-mrange inputs are illegal!\n") ;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-anat") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -anat \n");
exit (1);
}
Opt->aset_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-sig") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -sig \n");
exit (1);
}
Opt->sig_name = SUMA_copy_string(argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-pset") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -pset \n");
exit (1);
}
Opt->this_pset_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-gold") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -gold \n");
exit (1);
}
Opt->gold_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-gold_bias") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -gold_bias \n");
exit (1);
}
Opt->gold_bias_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-pstCgALL") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -pstCgALL \n");
exit (1);
}
Opt->pstCgALLname = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-priCgL") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -priCgL \n");
exit (1);
}
Opt->priCgLname = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-priCgALL") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -priCgALL \n");
exit (1);
}
Opt->priCgALLname = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-wL") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -wL \n");
exit (1);
}
Opt->wL = atof(argv[kar]);
if (Opt->wL < 0.0 || Opt->wL > 1.0) {
SUMA_S_Errv("-wL must be between 0 and 1.0, have %s", argv[kar]);
exit(1);
}
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-priCgA") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -priCgA \n");
exit (1);
}
Opt->priCgAname = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-wA") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -wA \n");
exit (1);
}
Opt->wA = atof(argv[kar]);
if (Opt->wA < 0.0 || Opt->wA > 1.0) {
SUMA_S_Errv("-wA must be between 0 and 1.0, have %s", argv[kar]);
exit(1);
}
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-cset") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -cset \n");
exit (1);
}
Opt->this_cset_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-fset") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -fset \n");
exit (1);
}
Opt->this_fset_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-xset") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -xset \n");
exit (1);
}
Opt->this_xset_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-tdist") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -tdist \n");
exit (1);
}
Opt->ndist_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-labeltable") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -labeltable \n");
exit (1);
}
Opt->labeltable_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-sphere_hood") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -sphere_hood \n");
exit (1);
}
Opt->na = atof(argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-blur_meth") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -blur_meth \n");
exit (1);
}
if (!strcmp(argv[kar],"BIM")) Opt->blur_meth = SEG_BIM;
else if (!strncmp(argv[kar],"LS",2)) Opt->blur_meth = SEG_LSB;
else if (!strcmp(argv[kar],"BNN")) Opt->blur_meth = SEG_BNN;
else if (!strcmp(argv[kar],"BFT")) Opt->blur_meth = SEG_BFT;
else {
SUMA_S_Errv("-blur_meth %s not valid\n", argv[kar]);
exit(1);
}
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-prefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -prefix \n");
exit (1);
}
Opt->smode = storage_mode_from_filename(argv[kar]);
Opt->proot = argv[kar];
Opt->prefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->crefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->pgrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->cgrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->frefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->xrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
sprintf(Opt->prefix,"%s.p", argv[kar]);
sprintf(Opt->pgrefix,"%s.pg", argv[kar]);
sprintf(Opt->crefix,"%s.c", argv[kar]);
sprintf(Opt->cgrefix,"%s.cg", argv[kar]);
sprintf(Opt->frefix,"%s.f", argv[kar]);
sprintf(Opt->xrefix,"%s.x", argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-pprefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -pprefix \n");
exit (1);
}
Opt->smode = storage_mode_from_filename(argv[kar]);
Opt->prefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
sprintf(Opt->prefix,"%s", argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-fprefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -fprefix \n");
exit (1);
}
Opt->smode = storage_mode_from_filename(argv[kar]);
Opt->frefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
sprintf(Opt->frefix,"%s", argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-cprefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -cprefix \n");
exit (1);
}
Opt->smode = storage_mode_from_filename(argv[kar]);
Opt->crefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
sprintf(Opt->crefix,"%s", argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-cgprefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -cgprefix \n");
exit (1);
}
Opt->smode = storage_mode_from_filename(argv[kar]);
Opt->cgrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
sprintf(Opt->cgrefix,"%s", argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-pgprefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -pgprefix \n");
exit (1);
}
Opt->smode = storage_mode_from_filename(argv[kar]);
Opt->pgrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
sprintf(Opt->pgrefix,"%s", argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-xprefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -xprefix \n");
exit (1);
}
Opt->smode = storage_mode_from_filename(argv[kar]);
Opt->xrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
sprintf(Opt->xrefix,"%s", argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-bias_classes") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -bias_classes \n");
exit (1);
}
Opt->bias_classes = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-group_classes") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -group_classes \n");
exit (1);
}
Opt->group_classes = NI_strict_decode_string_list(argv[kar] ,";");
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-group_keys") == 0)) {
NI_str_array *nstr=NULL; int ii;
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -group_keys \n");
exit (1);
}
if (!(nstr = NI_strict_decode_string_list(argv[kar] ,";, "))){
ERROR_exit("Bad option %s after -group_keys", argv[kar]);
}
Opt->group_keys = (int *)calloc(nstr->num, sizeof(int));
for (ii=0;ii<nstr->num; ++ii)
Opt->group_keys[ii] = strtol(nstr->str[ii],NULL,10);
NI_delete_str_array(nstr);nstr=NULL;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-classes") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -classes \n");
exit (1);
}
Opt->clss = NI_strict_decode_string_list(argv[kar] ,";, ");
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-split_classes") == 0)) {
NI_str_array *nstr=NULL; int ii;
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -split_classes \n");
exit (1);
}
nstr = NI_strict_decode_string_list(argv[kar] ,";, ");
Opt->Split = (int *)calloc(nstr->num+1, sizeof(int));
for (ii=0;ii<nstr->num; ++ii) {
Opt->Split[ii] = strtol(nstr->str[ii],NULL,10);
if (Opt->Split[ii]<1 || Opt->Split[ii]>9) {
SUMA_S_Errv("Bad split value of %d in %s\n",
Opt->Split[ii], argv[kar]);
exit(1);
}
}
Opt->Split[nstr->num]=-1; /* plug */
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-other") == 0)) {
Opt->Other = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-no_other") == 0)) {
Opt->Other = 0;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-keys") == 0)) {
NI_str_array *nstr=NULL; int ii;
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -keys \n");
exit (1);
}
if (!(nstr = NI_strict_decode_string_list(argv[kar] ,";, "))){
ERROR_exit("Bad option %s after -keys", argv[kar]);
}
Opt->keys = (int *)calloc(nstr->num, sizeof(int));
for (ii=0;ii<nstr->num; ++ii)
Opt->keys[ii] = strtol(nstr->str[ii],NULL,10);
NI_delete_str_array(nstr);nstr=NULL;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-bias_order") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need integer after -bias_order \n");
exit (1);
}
Opt->bias_param = atof(argv[kar]);
Opt->bias_meth = "Poly";
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-bias_fwhm") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need integer after -bias_fwhm \n");
exit (1);
}
Opt->bias_param = atof(argv[kar]);
Opt->bias_meth = "Wells";
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-enhance_cset_init") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need integer after -enhance_cset_init \n");
exit (1);
}
Opt->N_enhance_cset_init = atoi(argv[kar]);
SUMA_S_Err("Option not in use at the moment");
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-main_N") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need integer after -main_N \n");
exit (1);
}
Opt->N_main = atoi(argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-mixfloor") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need value between 0 and 1/(number of classes)"
" after -mixfloor \n");
exit (1);
}
Opt->mix_frac_floor = atof(argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-clust_cset_init") == 0)) {
Opt->clust_cset_init = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-no_clust_cset_init") == 0)) {
Opt->clust_cset_init = 0;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-uid") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -uid \n");
exit (1);
}
snprintf(Opt->uid,128,"%s",argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-mixfrac") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -mixfrac \n");
exit (1);
}
Opt->mixopt = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-Bmrf") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need value after -Bmrf \n");
exit (1);
}
Opt->B = atof(argv[kar]);
brk = 1;
}
if (!brk) {
fprintf (stderr,"Option %s not understood. \n"
"Try -help for usage\n", argv[kar]);
suggest_best_prog_option(argv[0], argv[kar]);
exit (1);
} else {
brk = 0;
kar ++;
}
}
if (!Opt->prefix) Opt->prefix = strdup("./GenPriorsOut.p");
if (!Opt->frefix) Opt->frefix = strdup("./GenPriorsOut.f");
if (!Opt->xrefix) Opt->xrefix = strdup("./GenPriorsOut.x");
if (!Opt->crefix) Opt->crefix = strdup("./GenPriorsOut.c");
if (Opt->uid[0]=='\0') UNIQ_idcode_fill(Opt->uid);
if (Opt->VoxDbg > -1 && !Opt->VoxDbgOut) {
char stmp[256];
sprintf(stmp,"%d.dbg", Opt->VoxDbg);
Opt->VoxDbgOut = fopen(stmp,"w");
}
RETURN(Opt);
}
SUMA_GENERIC_PROG_OPTIONS_STRUCT *
SUMA_SurfMatch_ParseInput( char *argv[], int argc,
SUMA_GENERIC_ARGV_PARSE *ps)
{
static char FuncName[]={"SUMA_SurfMatch_ParseInput"};
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt=NULL;
int kar;
SUMA_Boolean brk;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
Opt = SUMA_Alloc_Generic_Prog_Options_Struct();
Opt->s=NULL;
Opt->flt1 = 1.0;
Opt->b1 = 0;
Opt->efrac = 0.0;
kar = 1;
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_SurfMatch(ps, strlen(argv[kar])>3?1:0);
exit (0);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
if (!brk && (strcmp(argv[kar], "-warp") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a string after -warp \n");
exit (1);
}
++kar;
if (!strcmp(argv[kar],"shift_only") ||
!strcmp(argv[kar],"sho")) {
Opt->s = SUMA_copy_string("shft");
} else if (!strcmp(argv[kar],"shift_rotate") ||
!strcmp(argv[kar],"sro")) {
Opt->s = SUMA_copy_string("shft+rot");
} else if (!strcmp(argv[kar],"shift_rotate_scale") ||
!strcmp(argv[kar],"srs")) {
Opt->s = SUMA_copy_string("shft+rot+scl");
} else if (!strcmp(argv[kar],"affine_general") ||
!strcmp(argv[kar],"aff")) {
Opt->s = SUMA_copy_string("shft+rot+scl+shr");
} else {
SUMA_S_Errv("Bad -warp parameter of %s\n"
"Choose from sho, sro, srs, or aff\n",
argv[kar]);
exit(1);
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-city") == 0))
{
Opt->b1 = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-prefix") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a number after -prefix \n");
exit (1);
}
Opt->out_prefix = SUMA_copy_string(argv[++kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-depthlimit") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a number after -depthlimit \n");
exit (1);
}
Opt->flt1 = atof(argv[++kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-reduce_ref") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a number after -reduce_ref \n");
exit (1);
}
Opt->efrac = atof(argv[++kar]);
brk = YUP;
}
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 && !ps->arg_checked[kar]) {
fprintf (SUMA_STDERR,
"Error SurfMatch: Option %s not understood\n", argv[kar]);
suggest_best_prog_option(argv[0], argv[kar]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}
if (!Opt->out_prefix) {
Opt->out_prefix = SUMA_copy_string("SurfMatch.gii");
THD_force_ok_overwrite(1) ;
}
if (!Opt->s) {
Opt->s = SUMA_copy_string("shft");
}
SUMA_RETURN(Opt);
}
SEG_OPTS *GenFeatureDist_ParseInput (SEG_OPTS *Opt, char *argv[], int argc)
{
static char FuncName[]={"GenFeatureDist_ParseInput"};
int kar, i, ind, exists;
char *outname, cview[10], *sbuf=NULL;
int brk = 0;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_ENTRY;
brk = 0;
kar = 1;
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) {
Opt->helpfunc(0);
exit (0);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
#ifdef USE_TRACING
if( strncmp(argv[kar],"-trace",5) == 0 ){
DBG_trace = 1 ;
brk = 1 ;
}
if( strncmp(argv[kar],"-TRACE",5) == 0 ){
DBG_trace = 2 ;
brk = 1 ;
}
#endif
if (!brk && (strcmp(argv[kar], "-debug") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -debug \n");
exit (1);
}
Opt->debug = atoi(argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-talk_afni") == 0)) {
Opt->ps->cs->talk_suma = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-openmp") == 0)) {
Opt->openmp = 1;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-no_openmp") == 0)) {
Opt->openmp = 0;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-vox_debug") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need 1D vox index after -vox_debug \n");
exit (1);
}
if (kar+2<argc) { /* see if we have ijk */
int iii, jjj, kkk;
if (argv[kar][0]!='-' && argv[kar][1]!='-' && argv[kar][2]!='-' &&
(iii = atoi(argv[kar ])) >= 0 &&
(jjj = atoi(argv[kar+1])) >= 0 &&
(kkk = atoi(argv[kar+2])) >= 0 ) {
Opt->VoxDbg3[0]=iii;
Opt->VoxDbg3[1]=jjj;
Opt->VoxDbg3[2]=kkk;
++kar; ++kar;
}
}
if (Opt->VoxDbg3[0] < 0) {
Opt->VoxDbg = atoi(argv[kar]);
}
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-vox_debug_file") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need filename after -vox_debug_file \n");
exit (1);
}
if (!strcmp(argv[kar],"-")) {
Opt->VoxDbgOut = stdout;
} else if (!strcmp(argv[kar],"+")) {
Opt->VoxDbgOut = stderr;
} else {
Opt->VoxDbgOut = fopen(argv[kar],"w");
}
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-cmask") == 0)) {
kar ++;
if (kar >= argc) {
ERROR_exit("-cmask option requires a following argument!\n");
}
Opt->cmask = EDT_calcmask( argv[kar] , &(Opt->dimcmask), 0 ) ;
if( Opt->cmask == NULL ) ERROR_exit("Can't compute -cmask!\n");
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-mask") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -mask \n");
exit (1);
}
Opt->mset_name = argv[kar];
brk = 1;
}
if( !brk && (strncmp(argv[kar],"-mrange",5) == 0) ){
if( kar+2 >= argc )
ERROR_exit("-mrange option requires 2 following arguments!\n");
Opt->mask_bot = strtod( argv[++kar] , NULL ) ;
Opt->mask_top = strtod( argv[++kar] , NULL ) ;
if( Opt->mask_top < Opt->mask_bot )
ERROR_exit("-mrange inputs are illegal!\n") ;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-anat") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -anat \n");
exit (1);
}
Opt->aset_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-sig") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -sig \n");
exit (1);
}
while (kar < argc && argv[kar][0] != '-') {
sbuf =
SUMA_append_replace_string(sbuf, argv[kar], " ", 1);
++kar;
}
if (kar < argc && argv[kar][0] == '-') --kar; /* unwind */
Opt->sig_names = SUMA_NI_str_array(Opt->sig_names, sbuf, "add");
SUMA_free(sbuf); sbuf = NULL;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-samp") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -samp \n");
exit (1);
}
while (kar < argc && argv[kar][0] != '-') {
sbuf =
SUMA_append_replace_string(sbuf, argv[kar], " ", 1);
++kar;
}
if (kar < argc && argv[kar][0] == '-') --kar; /* unwind */
Opt->samp_names = SUMA_NI_str_array(Opt->samp_names, sbuf, "add");
SUMA_free(sbuf); sbuf = NULL;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-hspec") == 0)) {
kar ++;
if (kar+3 >= argc) {
fprintf (stderr, "need 4 arguments after -hspec \n");
exit (1);
}
Opt->hspec = (SUMA_HIST **)
SUMA_realloc(Opt->hspec, (Opt->N_hspec+1)*sizeof(SUMA_HIST *));
Opt->hspec[Opt->N_hspec] = (SUMA_HIST*)SUMA_calloc(1,sizeof(SUMA_HIST));
Opt->hspec[Opt->N_hspec]->label = SUMA_copy_string(argv[kar++]);
Opt->hspec[Opt->N_hspec]->min = (float)strtod(argv[kar++],NULL);
Opt->hspec[Opt->N_hspec]->max = (float)strtod(argv[kar++],NULL);
Opt->hspec[Opt->N_hspec]->K = (float)strtod(argv[kar],NULL);
++Opt->N_hspec;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-prefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -prefix \n");
exit (1);
}
Opt->smode = storage_mode_from_filename(argv[kar]);
Opt->proot = argv[kar];
Opt->prefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->crefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->pgrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->cgrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->frefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
Opt->xrefix = (char*)calloc(strlen(argv[kar])+20, sizeof(char));
sprintf(Opt->prefix,"%s.p", argv[kar]);
sprintf(Opt->pgrefix,"%s.pg", argv[kar]);
sprintf(Opt->crefix,"%s.c", argv[kar]);
sprintf(Opt->cgrefix,"%s.cg", argv[kar]);
sprintf(Opt->frefix,"%s.f", argv[kar]);
sprintf(Opt->xrefix,"%s.x", argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-classes") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -classes \n");
exit (1);
}
Opt->clss = NI_strict_decode_string_list(argv[kar] ,";, ");
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-features") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -features \n");
exit (1);
}
Opt->feats = NI_strict_decode_string_list(argv[kar] ,";, ");
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-keys") == 0)) {
NI_str_array *nstr=NULL; int ii;
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -keys \n");
exit (1);
}
if (!(nstr = NI_strict_decode_string_list(argv[kar] ,";, "))){
ERROR_exit("Bad option %s after -keys", argv[kar]);
}
Opt->keys = (int *)calloc(nstr->num, sizeof(int));
for (ii=0;ii<nstr->num; ++ii)
Opt->keys[ii] = strtol(nstr->str[ii],NULL,10);
NI_delete_str_array(nstr);nstr=NULL;
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-labeltable") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -labeltable \n");
exit (1);
}
Opt->labeltable_name = argv[kar];
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-uid") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -uid \n");
exit (1);
}
snprintf(Opt->uid,128,"%s",argv[kar]);
brk = 1;
}
if (!brk && (strcmp(argv[kar], "-ShowTheseHists") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (stderr, "need argument after -ShowTheseHists \n");
exit (1);
}
{
NI_str_array *hisnames=NULL;
SUMA_HIST *hh=NULL;
int ii=0;
hisnames = NI_strict_decode_string_list(argv[kar],";, ");
for (ii=0; ii<hisnames->num; ++ii) {
if ((hh = SUMA_read_hist(hisnames->str[ii]))) {
SUMA_Show_hist(hh, 1, NULL);
hh = SUMA_Free_hist(hh);
} else {
SUMA_S_Errv("Hist %s not found.\n", hisnames->str[ii]);
exit(1);
}
}
hisnames = SUMA_free_NI_str_array(hisnames);
}
exit(0);
brk = 1;
}
if (!brk) {
fprintf (stderr,"Option #%d %s not understood. \n"
"Try -help for usage\n", kar, argv[kar]);
suggest_best_prog_option(argv[0], argv[kar]);
exit (1);
} else {
brk = 0;
kar ++;
}
}
if (!Opt->prefix) Opt->prefix = strdup("./GenFeatureDistOut.p");
if (!Opt->frefix) Opt->frefix = strdup("./GenFeatureDistOut.f");
if (!Opt->xrefix) Opt->xrefix = strdup("./GenFeatureDistOut.x");
if (!Opt->crefix) Opt->crefix = strdup("./GenFeatureDistOut.c");
if (Opt->uid[0]=='\0') UNIQ_idcode_fill(Opt->uid);
if (Opt->VoxDbg > -1 && !Opt->VoxDbgOut) {
char stmp[256];
sprintf(stmp,"%d.GFD.dbg", Opt->VoxDbg);
Opt->VoxDbgOut = fopen(stmp,"w");
}
SUMA_RETURN(Opt);
}
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);
}
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[]={"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 */
/*!\**
File : SUMA.c
\author : Ziad Saad
Date : Thu Dec 27 16:21:01 EST 2001
Purpose :
Input paramters :
\param
\param
Usage :
SUMA ( )
Returns :
\return
\return
Support :
\sa OpenGL prog. Guide 3rd edition
\sa varray.c from book's sample code
Side effects :
***/
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"suma"};
int kar, i;
SUMA_SFname *SF_name;
SUMA_Boolean brk, SurfIn;
char *NameParam, *AfniHostName = NULL, *s = NULL, *pdspec=NULL, *pdsv=NULL;
char *specfilename[SUMA_MAX_N_GROUPS], *VolParName[SUMA_MAX_N_GROUPS];
byte InMem[SUMA_MAX_N_GROUPS];
SUMA_SurfSpecFile *Specp[SUMA_MAX_N_GROUPS];
SUMA_Axis *EyeAxis;
SUMA_EngineData *ED= NULL;
DList *list = NULL;
DListElmt *Element= NULL;
int iv15[15], N_iv15, ispec, nspec;
struct stat stbuf;
float fff=0.0;
int Start_niml = 0;
SUMA_Boolean Domemtrace = YUP;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
SUMAg_CF->isGraphical = YUP;
ps = SUMA_Parse_IO_Args(argc, argv, "-i;-t;-dset;-do;");
/* initialize Volume Parent and AfniHostName to nothing */
for (ispec=0; ispec < SUMA_MAX_N_GROUPS; ++ispec) {
specfilename[ispec] = NULL;
VolParName[ispec] = NULL;
Specp[ispec] = NULL;
InMem[ispec] = 0;
}
AfniHostName = NULL;
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
/* call the function to parse the other surface mode inputs */
ispec = 0;
if (LocalHead) SUMA_Show_IO_args(ps);
if (ps->i_N_surfnames || ps->t_N_surfnames || ps->N_DO) {
SUMA_LH("-i and/or -t surfaces on command line!");
Specp[ispec] = SUMA_IO_args_2_spec (ps, &nspec);
if (Specp[ispec]) {
++ispec;
if (nspec != 1) {
SUMA_S_Errv("-spec is being parsed separately here, "
"expecting one spec only from SUMA_IO_args_2_spec, \n"
"got %d\n", nspec);
exit (1);
}
} else {
SUMA_S_Err("Failed to load -i/-t surfaces");
exit(1);
}
}
/* Work the options */
kar = 1;
brk = NOPE;
SurfIn = NOPE;
Domemtrace = YUP;
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_usage (ps, strlen(argv[kar]) > 3 ? 2:1);
exit (0); /* return a good status on -help 12 Jul 2013 [rickr] */
}
/* -list_ports list and quit */
if( strncmp(argv[kar],"-list_ports", 8) == 0) {
show_ports_list(); exit(0);
}
/* -port_number and quit */
if( strncmp(argv[kar],"-port_number", 8) == 0) {
int pp = 0;
if( ++kar >= argc )
ERROR_exit("need an argument after -port_number!");
pp = get_port_named(argv[kar]);
if (strcmp(argv[kar-1], "-port_number_quiet")) {
fprintf(stdout, "\nPort %s: %d\n", argv[kar], pp);
} else {
fprintf(stdout, "%d\n", pp);
}
if (pp < 1) exit(1);
else exit(0);
}
if (strcmp(argv[kar], "-visuals") == 0) {
SUMA_ShowAllVisuals ();
exit (0);
}
if (strcmp(argv[kar], "-brethren_windows") == 0) {
Display *dd=NULL; Window ww;
if (!(dd = XOpenDisplay(NULL))) {
SUMA_S_Err("No display "); exit(1);
}
ww = XDefaultRootWindow(dd);
SUMA_WindowsOnRootDisplay(dd, ww , 0);
exit (0);
}
if (strcmp(argv[kar], "-version") == 0) {
s = SUMA_New_Additions (0.0, 1);
fprintf (SUMA_STDOUT,"%s\n", s);
SUMA_free(s); s = NULL;
exit (0);
}
if (strcmp(argv[kar], "-sources") == 0) {
s = SUMA_sources_Info();
fprintf (SUMA_STDOUT,"%s\n", s);
SUMA_free(s); s = NULL;
exit (0);
}
if (strcmp(argv[kar], "-help_nido") == 0) {
s = SUMA_NIDO_Info();
fprintf (SUMA_STDOUT,"%s\n", s);
SUMA_free(s); s = NULL;
exit (0);
}
if (strcmp(argv[kar], "-all_latest_news") == 0) {
s = SUMA_New_Additions (-1.0, 0);
fprintf (SUMA_STDOUT,"%s\n", s);
SUMA_free(s); s = NULL;
exit (0);
}
if (strcmp(argv[kar], "-help_sphinx_interactive") == 0) {
FILE *fout = NULL;
if( ++kar >= argc )
ERROR_exit("need a file name after -help_sphinx_interactive!");
fout = fopen(argv[kar],"w");
if (!fout) {
SUMA_S_Err("Failed to open %s for writing", argv[kar]);
exit(1);
}
SUMA_help_message(fout,SPX);
fclose(fout); fout = NULL;
exit (0);
}
if (strcmp(argv[kar], "-help_interactive") == 0) {
FILE *fout = fopen("Mouse_Keyboard_Controls.txt","w");
if (!fout) {
SUMA_S_Err("Failed to open Mouse_Keyboard_Controls.txt for writing");
exit(1);
}
SUMA_help_message(fout,TXT);
fclose(fout); fout = NULL;
exit (0);
}
if (strcmp(argv[kar], "-test_help_string_edit") == 0) {
SUMA_Sphinx_String_Edit_Help(SUMA_STDOUT, 0);
exit(0);
}
if (strcmp(argv[kar], "-test_help_string_edit_web") == 0) {
SUMA_Sphinx_String_Edit_Help(SUMA_STDOUT, 1);
exit(0);
}
if (strcmp(argv[kar], "-environment") == 0) {
s = SUMA_env_list_help (0, TXT);
fprintf (SUMA_STDOUT,
"#SUMA ENVIRONMENT \n"
"# If you do not have a ~/.sumarc file, cannot find a SUMA\n"
"# environment variable that's been mentioned in documentation,\n"
"# or fervently desire to update your current ~/.sumarc with \n"
"# all the latest variables that SUMA uses, you should run: \n"
"# \n"
"# suma -update_env\n"
"# \n"
"# Unless you have setup SUMA environment variables outside of\n"
"# your ~/.sumarc file, updating your ~/.sumarc file with \n"
"# 'suma -update_env' WILL NOT ALTER changes you have already\n"
"# made to the variables in your current ~/.sumarc. \n"
"# For this reason consider running the update command after each \n"
"# upgrade of your AFNI/SUMA binaries.\n"
"***ENVIRONMENT\n"
"%s\n", s);
SUMA_free(s); s = NULL;
exit (0);
}
if (strcmp(argv[kar], "-default_env") == 0) {
s = SUMA_env_list_help (1, NO_FORMAT);
fprintf (SUMA_STDOUT,
"#SUMA DEFAULT ENVIRONMENT (user settings ignored)\n"
"# see also suma -udate_env or suma -environment\n"
"# \n"
"***ENVIRONMENT\n"
"%s\n", s);
SUMA_free(s); s = NULL;
exit (0);
}
if (strcmp(argv[kar], "-update_env") == 0) {
if (system("suma -environment > ___sumarc")) {
SUMA_S_Err("Failed to create env file.");
exit(1);
}
if (SUMA_filexists("~/.sumarc")) {
if (system("\\cp -f ~/.sumarc ~/.sumarc-bak")) {
SUMA_S_Err("Failed to backup ~/.sumarc to ~/.sumarc-bak.");
exit(1);
}
}
if (system("\\mv ___sumarc ~/.sumarc")) {
SUMA_S_Err("Failed to copy newrc (___sumarc) to ~/.sumarc");
exit(1);
}
SUMA_S_Note("Environment update done.");
exit(0);
}
if (strcmp(argv[kar], "-latest_news") == 0) {
s = SUMA_New_Additions (0.0, 0);
fprintf (SUMA_STDOUT,"%s\n", s);
SUMA_free(s); s = NULL;
exit (0);
}
if (strcmp(argv[kar], "-progs") == 0) {
s = SUMA_All_Programs();
fprintf (SUMA_STDOUT,"%s\n", s);
SUMA_free(s); s = NULL;
exit (0);
}
if (strcmp(argv[kar], "-motif_ver") == 0) { /* 9 Mar 2009 [rickr] */
show_motif_version_string();
exit (0);
}
if (!brk && (strcmp(argv[kar], "-iodbg") == 0)) {
fprintf(SUMA_STDERR,"Error %s: Obsolete, use -trace\n", FuncName);
exit (0);
/*
fprintf(SUMA_STDOUT,
"Warning %s: SUMA running in in/out debug mode.\n", FuncName);
SUMA_INOUT_NOTIFY_ON;
brk = YUP;
*/
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
#if SUMA_MEMTRACE_FLAG
if (!brk && (strcmp(argv[kar], "-memdbg") == 0)) {
fprintf(SUMA_STDOUT,"Error %s: -memdbg is obsolete, use -trace\n",
FuncName);
exit (0);
fprintf( SUMA_STDOUT,
"Warning %s: SUMA running in memory trace mode.\n",
FuncName);
SUMAg_CF->MemTrace = YUP;
#ifdef USING_MCW_MALLOC
#endif
brk = YUP;
}
#endif
if (!brk && (strcmp(argv[kar], "-dev") == 0)) {
fprintf(SUMA_STDOUT,
"Warning %s: SUMA running in developer mode, "
"some options may malfunction.\n", FuncName);
SUMAg_CF->Dev = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-fake_cmap") == 0)) {
SUMA_S_Warn("-fake_cmap is for automatic selfies of the widgets.\n"
"You should not use this option for any other reason\n");
SUMAg_CF->Fake_Cmap = YUP;
brk = YUP;
}
if (!brk && SUMAg_CF->Dev && (strcmp(argv[kar], "-truth_table") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need expression after -truth_table \n");
exit (1);
}
SUMA_bool_eval_truth_table(argv[kar], 0); exit(0);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-niml") == 0)) {
Start_niml = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-noniml") == 0)) {
Start_niml = -1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-vp") == 0 ||
strcmp(argv[kar], "-sa") == 0 ||
strcmp(argv[kar], "-sv") == 0))
{
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -vp|-sa|-sv \n");
exit (1);
}
if (ispec < 1) {
fprintf (SUMA_STDERR,
"a -spec option must precede the first -sv option\n");
exit (1);
}
if (!specfilename[ispec-1] && !Specp[ispec-1]) {
fprintf (SUMA_STDERR,
"a -spec option must precede each -sv option\n");
exit (1);
}
VolParName[ispec-1] = argv[kar];
if (LocalHead) {
fprintf(SUMA_STDOUT, "Found: %s\n", VolParName[ispec]);
}
brk = YUP;
}
if (!brk && strcmp(argv[kar], "-drive_com") == 0)
{
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -drive_com\n");
exit (1);
}
SUMAg_CF->dcom = (char **)SUMA_realloc(SUMAg_CF->dcom,
(SUMAg_CF->N_dcom+1)*sizeof(char *));
SUMAg_CF->dcom[SUMAg_CF->N_dcom] = SUMA_copy_string(argv[kar]);
++SUMAg_CF->N_dcom;
brk = YUP;
}
if (!brk && strcmp(argv[kar], "-ah") == 0)
{
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -ah\n");
exit (1);
}
if (strcmp(argv[kar],"localhost") != 0) {
AfniHostName = argv[kar];
}else {
fprintf (SUMA_STDERR,
"localhost is the default for -ah\n"
"No need to specify it.\n");
}
/*fprintf(SUMA_STDOUT, "Found: %s\n", AfniHostName);*/
brk = YUP;
}
if (!brk && strcmp(argv[kar], "-spec") == 0)
{
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -spec \n");
exit (1);
}
if (ispec >= SUMA_MAX_N_GROUPS) {
fprintf (SUMA_STDERR,
"Cannot accept more than %d spec files.\n",
SUMA_MAX_N_GROUPS);
exit(1);
}
if (SUMA_is_predefined_SO_name(argv[kar], NULL,
&pdspec, &pdsv, NULL) == 3) {
specfilename[ispec] = pdspec; pdspec = NULL; /* Memory leak! */
VolParName[ispec] = pdsv; pdsv = NULL; /* Memory leak! */
} else {
specfilename[ispec] = argv[kar];
}
if (LocalHead) {
fprintf(SUMA_STDOUT, "Found: %s\n", specfilename[ispec]);
}
++ispec;
brk = YUP;
}
if (!brk && !ps->arg_checked[kar]) {
if ( !strcmp(argv[kar], "-i") ||
!strncmp(argv[kar], "-i_",3) ) {
fprintf (SUMA_STDERR,
"Error %s: Option %s not understood. \n"
" Make sure parameter after -i or -i_ is the full name of a surface.\n"
"%s",
FuncName, argv[kar],
strlen(argv[kar])==2 ?
"For -i to work, SUMA needs to guess at the surface type from\n"
" the filename extensions. If SUMA fails try the full -i_* option"
" instead.\n" : ""
);
} else {
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 ++;
}
}/* loop accross command ine options */
/* -ah option now checked for in ps */
if (ps->cs->afni_host_name && !AfniHostName) {
AfniHostName = SUMA_copy_string(ps->cs->afni_host_name);
}
#if 0
SUMA_S_Note("KILL ME");
{
int i,j, nl;
SUMA_TextBoxSize("Hello", &i,&j,&nl,NULL);
SUMA_TextBoxSize("",
&i,&j,&nl,GLUT_BITMAP_8_BY_13);
SUMA_TextBoxSize("O",
&i,&j,&nl,GLUT_BITMAP_8_BY_13);
SUMA_TextBoxSize(NULL,
&i,&j,&nl,GLUT_BITMAP_8_BY_13);
}
SUMA_ReadNIDO("/Users/ziad/SUMA_test_dirs/DO/TextDO/sample.niml.do", NULL);
exit(1);
#endif
/* Make surface loading pacifying */
SetLoadPacify(1);
#if 0
if (ps->N_DO) { /* Have DOs on command line */
if (Specp[0]) { /* Add to Specp[0] */
if (ps->N_DO + Specp[0]->N_DO > SUMA_MAX_DO_SPEC) {
SUMA_S_Warn("Too many DOs, increase static limit..");
/* ignore extras for now */
ps->N_DO = SUMA_MAX_DO_SPEC - Specp[0]->N_DO;
}
for (i=0; i<ps->N_DO; ++i) {
strcpy(Specp[0]->DO_name[Specp[0]->N_DO], ps->DO_name[i]);
Specp[0]->DO_type[Specp[0]->N_DO] = ps->DO_type[i];
++Specp[0]->N_DO;
}
} else {
Specp[0]
}
}
#endif
/* any Specp to be found ?*/
if (specfilename[0] == NULL && Specp[0] == NULL) {
SUMA_SurfaceObject **SOv=NULL;
int N_SOv = 0;
fprintf (SUMA_STDERR,
"\n"
"%s: \n"
" No input specified, loading some toy surfaces...\n"
" Use '.' and ',' to cycle between them.\n"
" See suma -help for assistance.\n"
"\n", FuncName);
/* create your own surface and put it in a spec file */
SOv = SUMA_GimmeSomeSOs(&N_SOv);
Specp[ispec] = SUMA_SOGroup_2_Spec (SOv, N_SOv);
SUMA_free(SOv); SOv = NULL;
InMem[ispec] = 1;
++ispec;
}
if(!SUMA_Assign_HostName (SUMAg_CF, AfniHostName, -1)) {
fprintf (SUMA_STDERR,
"Error %s: Failed in SUMA_Assign_HostName\n", FuncName);
exit (1);
}
#ifdef SUMA_DISASTER
/* a function to test Memtracing */
{
int *jnk;
jnk = SUMA_disaster();
SUMA_free(jnk); /* without the -trace, you'll get a
warning here if jnk is corrupted */
}
#endif
/* create an Eye Axis DO */
EyeAxis = SUMA_Alloc_Axis ("Eye Axis", AO_type);
if (EyeAxis == NULL) {
SUMA_error_message (FuncName,"Error Creating Eye Axis",1);
exit(1);
}
/* Store it into SUMAg_DOv */
if (!SUMA_AddDO( SUMAg_DOv, &SUMAg_N_DOv,
(void *)EyeAxis, AO_type, SUMA_SCREEN)) {
SUMA_error_message (FuncName,"Error Adding DO", 1);
exit(1);
}
/*fprintf (SUMA_STDERR, "SUMAg_N_DOv = %d created\n", SUMAg_N_DOv);
SUMA_Show_DOv(SUMAg_DOv, SUMAg_N_DOv, NULL);*/
/* Allocate space (and initialize) Surface Viewer Structure */
SUMAg_SVv = SUMA_Alloc_SurfaceViewer_Struct (SUMA_MAX_SURF_VIEWERS);
/* SUMAg_N_SVv gets updated in SUMA_X_SurfaceViewer_Create
and reflects not the number of elements in SUMAg_SVv which is
SUMA_MAX_SURF_VIEWERS, but the number of viewers that were realized
by X */
/* Check on initialization */
/*SUMA_Show_SurfaceViewer_Struct (SUMAg_cSV, stdout);*/
/* Create the Surface Viewer Window */
if (!SUMA_X_SurfaceViewer_Create ()) {
fprintf(stderr,"Error in SUMA_X_SurfaceViewer_Create. Exiting\n");
return 1;
}
for (i=0; i<ispec; ++i) {
if (!list) list = SUMA_CreateList();
ED = SUMA_InitializeEngineListData (SE_Load_Group);
if (!( Element = SUMA_RegisterEngineListCommand ( list, ED,
SEF_cp, (void *)specfilename[i],
SES_Suma, NULL, NOPE,
SEI_Head, NULL ))) {
fprintf(SUMA_STDERR,"Error %s: Failed to register command\n", FuncName);
exit (1);
}
if (!( Element = SUMA_RegisterEngineListCommand ( list, ED,
SEF_ip, (void *)Specp[i],
SES_Suma, NULL, NOPE,
SEI_In, Element ))) {
fprintf(SUMA_STDERR,"Error %s: Failed to register command\n", FuncName);
exit (1);
}
fff = (float) InMem[i];
if (!( Element = SUMA_RegisterEngineListCommand ( list, ED,
SEF_f, (void *)&fff,
SES_Suma, NULL, NOPE,
SEI_In, Element ))) {
fprintf(SUMA_STDERR,"Error %s: Failed to register command\n", FuncName);
exit (1);
}
if (!( Element = SUMA_RegisterEngineListCommand ( list, ED,
SEF_vp, (void *)VolParName[i],
SES_Suma, NULL, NOPE,
SEI_In, Element ))) {
fprintf(SUMA_STDERR,"Error %s: Failed to register command\n", FuncName);
exit (1);
}
N_iv15 = SUMA_MAX_SURF_VIEWERS;
if (N_iv15 > 15) {
fprintf( SUMA_STDERR,
"Error %s: trying to register more than 15 viewers!\n",
FuncName);
exit(1);
}
for (kar=0; kar<N_iv15; ++kar) iv15[kar] = kar;
if (!( Element = SUMA_RegisterEngineListCommand ( list, ED,
SEF_iv15, (void *)iv15,
SES_Suma, NULL, NOPE,
SEI_In, Element ))) {
fprintf(SUMA_STDERR,"Error %s: Failed to register command\n", FuncName);
exit (1);
}
if (!( Element = SUMA_RegisterEngineListCommand ( list, ED,
SEF_i, (void *)&N_iv15,
SES_Suma, NULL, NOPE,
SEI_In, Element ))) {
fprintf(SUMA_STDERR,"Error %s: Failed to register command\n", FuncName);
exit (1);
}
}
if (ispec > 0 && !SUMA_Engine (&list)) {
fprintf(SUMA_STDERR,"Error %s: Failed in SUMA_Engine\n", FuncName);
exit (1);
}
/* For some reason, I had to add the glLightfv line below
to force the lightflipping done in SUMA_SetupSVforDOs to take place
in the A viewer when first opened. I don't know why that is, especially
since other controllers would show up lit correctly without this
glLightfv line below.
To make matters worse, the A controller's light0_position is correctly
flipped.
It is just that the shading is done as if the position was never flipped.
Actually, without the line below, the first time you hit the F key (to
manually flip the light), nothing changes, that's because the light's position is unflipped, which is supposed to show the incorrect lighting.
You'll have to hit F again to have the lighting correctly flipped
and the shading reflecting it.... ZSS, Aug. 05 04 */
glLightfv(GL_LIGHT0, GL_POSITION, SUMAg_SVv[0].light0_position);
if (Start_niml != -1 && (Start_niml == 1|| AFNI_yesenv("SUMA_START_NIML"))) {
if (!list) list = SUMA_CreateList();
SUMA_REGISTER_HEAD_COMMAND_NO_DATA( list, SE_StartListening,
SES_Suma, NULL);
if (!SUMA_Engine (&list)) {
fprintf(SUMA_STDERR, "Error %s: SUMA_Engine call failed.\n", FuncName);
exit (1);
}
}
/* load the datasets onto the first SO, if any, else hope that dset
is some form of DO */
if (ps->N_dsetname>0) {
SUMA_SurfaceObject *SO = SUMA_findanySOp_inDOv(SUMAg_DOv,
SUMAg_N_DOv, NULL);
if (!SO) {
SUMA_LH("Could not find any SO, here is hoping dset is a DO");
}
for (i=0; i<ps->N_dsetname; ++i) {
if (!(SUMA_LoadDsetOntoSO_eng(ps->dsetname[i], SO, 1, 1, 1, NULL))) {
SUMA_S_Errv("Failed to load %s onto %s\n",
ps->dsetname[i], SO?SO->Label:"NULL");
}
}
}
SUMA_FreeGenericArgParse(ps); ps = NULL;
/* A Warning about no sumarc */
if (NoSumaRcFound()) {
SUMA_S_Warn(
"\n"
" No sumarc file found. You should create one by running the following:\n"
"\n"
" suma -update_env\n"
"\n"
" I also recommend you run 'suma -update_env' whenever you update AFNI.\n"
"\n"
" See details for -environment and -update_env options in suma -help's output.\n"
"\n");
}
/*Main loop */
XtAppMainLoop(SUMAg_CF->X->App);
/* Done, clean up time */
if (ispec) {
int k=0;
for (k=0; k<ispec; ++k) {
if (!SUMA_FreeSpecFields((Specp[k]))) {
SUMA_S_Err("Failed to free spec fields");
}
Specp[k] = NULL;
}
} ispec = 0;
if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv))
SUMA_error_message(FuncName,"DO Cleanup Failed!",1);
if (!SUMA_Free_SurfaceViewer_Struct_Vect (SUMAg_SVv, SUMA_MAX_SURF_VIEWERS))
SUMA_error_message(FuncName,"SUMAg_SVv Cleanup Failed!",1);
if (!SUMA_Free_CommonFields(SUMAg_CF))
SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1);
SUMA_RETURN(0); /* ANSI C requires main to return int. */
}/* Main */
SUMA_GENERIC_PROG_OPTIONS_STRUCT *
SUMA_3dBRAIN_VOYAGERtoAFNI_ParseInput(char *argv[], int argc,
SUMA_GENERIC_ARGV_PARSE *ps)
{
static char FuncName[]={"SUMA_3dBRAIN_VOYAGERtoAFNI_ParseInput"};
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt=NULL;
int kar;
SUMA_Boolean brk;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
Opt = SUMA_Alloc_Generic_Prog_Options_Struct();
Opt->b1 = 0;
Opt->b2 = 0;
Opt->Icold = -1;
Opt->out_prefix = NULL;
kar = 1;
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_3dBRAIN_VOYAGERtoAFNI(ps);
exit (0);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
if (!brk && (strcmp(argv[kar], "-input") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -input\n");
exit (1);
}
Opt->in_name = argv[kar];
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], "-tlrc") == 0)) {
Opt->Icold = VIEW_TALAIRACH_TYPE;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-acpc") == 0)) {
Opt->Icold = VIEW_ACPCALIGNED_TYPE;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-orig") == 0)) {
Opt->Icold = VIEW_ORIGINAL_TYPE;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-bs") == 0)) {
Opt->b1 = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-qx") == 0)) {
Opt->b2 = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-debug") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need integer argument after -debug\n");
exit (1);
}
Opt->debug = atoi(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]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}
SUMA_RETURN(Opt);
}
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);
}
