int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"SampBias"};
int N_Spec = -1;
int i;
SUMA_SurfaceObject *SO = NULL;
SUMA_SurfSpecFile *Spec;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
void *SO_name = NULL;
SUMA_DSET *dset=NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_KUBATEST_OPTIONS Opt;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
ps = SUMA_Parse_IO_Args(argc, argv, "-i;-spec;-sv;-s;-o;");
SUMA_SampBias_ParseInput (argv, argc, &Opt, ps);
if (argc < 4)
{
SUMA_S_Err("Too few arguments");
exit (0);
}
/* read surface */
Spec = SUMA_IO_args_2_spec(ps, &N_Spec);
if (N_Spec == 0) {
SUMA_S_Err("No surfaces found.");
exit(1);
}
SUMA_LH("Loading surface...");
SO = SUMA_Load_Spec_Surf_with_Metrics(Spec, 0, ps->sv[0], Opt.debug);
if (!SO) {
fprintf (SUMA_STDERR,"Error %s:\n"
"Failed to find surface\n"
"in spec file. \n",
FuncName );
exit(1);
}
if (!(dset = calcWithOffsets(SO, &Opt))) {
SUMA_S_Err("Failed to calc ratios");
exit(1);
}
if (!SUMA_AddNgrHist(dset->ngr, "SampBias", argc, argv)) {
SUMA_S_Err("Failed to add history");
}
if (Opt.prefix) {
char *cc = SUMA_WriteDset_s(Opt.prefix, dset,
SUMA_NO_DSET_FORMAT, 1,1);
if (cc) SUMA_free(cc);
}
SUMA_LH("clean up");
if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) {
SUMA_SL_Err("DO Cleanup Failed!");
}
if (Opt.outfile) SUMA_free(Opt.outfile);
if (Opt.histnote) SUMA_free(Opt.histnote);
if (Opt.prefix) SUMA_free(Opt.prefix);
if (Opt.segdo) SUMA_free(Opt.segdo);
if (!SUMA_FreeSpecFields(Spec)) {
SUMA_S_Err("Failed to free SpecFields");
} SUMA_free(Spec); Spec = NULL;
if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL;
if (!SUMA_Free_CommonFields(SUMAg_CF)) {
SUMA_SL_Err("SUMAg_CF Cleanup Failed!");}
SUMA_RETURN(0);
}
/*!\**
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 */
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"SurfClust"};
int kar, SO_read, *ni=NULL, N_ni, cnt, i, *nip=NULL, N_Spec = 0;
float *data_old = NULL, *far = NULL, *nv=NULL, *nt = NULL;
void *SO_name = NULL;
SUMA_SurfaceObject *SO = NULL, *SOnew = NULL;
MRI_IMAGE *im = NULL;
SUMA_DSET_FORMAT iform;
SUMA_SURFCLUST_OPTIONS *Opt;
SUMA_SurfSpecFile *Spec=NULL;
DList *list = NULL;
SUMA_DSET *dset = NULL;
float *NodeArea = NULL;
FILE *clustout=NULL;
char *ClustOutName = NULL, *params=NULL, stmp[200];
char sapa[32]={""}, sapd[32]={""}, sapn[32]={""}, sap[100]={""};
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
ps = SUMA_Parse_IO_Args(argc, argv, "-spec;-i;-t;-sv;-s;");
Opt = SUMA_SurfClust_ParseInput (argv, argc, ps);
if (argc < 6)
{
SUMA_S_Err("Too few options");
usage_SUMA_SurfClust(0);
exit (1);
}
if (Opt->DistLim >= 0.0) {
sprintf(sapd, "_r%.1f", Opt->DistLim);
} else {
sprintf(sapd, "_e%d", -(int)Opt->DistLim);
}
if (Opt->AreaLim < 0) {
sapa[0]='\0';
} else {
sprintf(sapa, "_a%.1f", Opt->AreaLim);
}
if (Opt->NodeLim < 0) {
sapn[0]='\0';
} else {
sprintf(sapn, "_n%d", Opt->NodeLim);
}
sprintf(sap, "%s%s%s", sapd, sapa, sapn);
if (Opt->WriteFile) {
sprintf(stmp,"_ClstTable%s.1D", sap);
ClustOutName = SUMA_append_string(Opt->out_prefix, stmp);
if (SUMA_filexists(ClustOutName) && !THD_ok_overwrite()) {
fprintf (SUMA_STDERR,
"Error %s:\n"
"Output file %s exists, will not overwrite.\n",
FuncName, ClustOutName);
exit(1);
}
}
Spec = SUMA_IO_args_2_spec(ps, &N_Spec);
if (N_Spec == 0) {
SUMA_S_Err("No surfaces found.");
exit(1);
}
if (N_Spec != 1) {
SUMA_S_Err("Multiple spec at input.");
exit(1);
}
if (Spec->N_Surfs != 1) {
SUMA_S_Err("1 and only 1 surface expected at input");
exit(1);
}
SUMA_LH("Loading surface...");
SO = SUMA_Load_Spec_Surf(Spec, 0, ps->sv[0], 0);
if (!SO) {
fprintf (SUMA_STDERR,"Error %s:\n"
"Failed to find surface\n"
"in spec file. \n",
FuncName );
exit(1);
}
if (!SUMA_SurfaceMetrics(SO, "EdgeList", NULL)) {
SUMA_S_Err("Failed to compute edgelist");
exit(1);
}
NodeArea = SUMA_CalculateNodeAreas(SO, NULL);
if (!NodeArea) {
SUMA_S_Err("Failed to calculate Node Areas.\n");
exit(1);
}
/* load the data */
iform = SUMA_NO_DSET_FORMAT;
dset = SUMA_LoadDset_s (Opt->in_name, &iform, 0);
if (LocalHead) SUMA_ShowDset(dset, 0, NULL);
if (!dset) { SUMA_S_Err( "Failed to load dataset.\n"
"Make sure file exists\n"
"and is of the specified\n"
"format.");
exit(1); }
if (!SUMA_OKassign(dset, SO)) {
SUMA_SL_Err("Failed to assign data set to surface.");
exit(1);
}
/* get the node index column */
nip = SUMA_GetNodeDef(dset);
N_ni = SDSET_VECLEN(dset);
if (!nip) {
SUMA_S_Err("Failed to find node index column");
exit(1);
}
/* copy nip's contents because you will be modifying in the
thresholding below */
ni = (int *)SUMA_malloc(N_ni*sizeof(int));
memcpy (ni, nip, N_ni*sizeof(int));
nv = SUMA_DsetCol2Float(dset, Opt->labelcol, 0);
if (!nv) {
SUMA_S_Err("Failed to find node value column");
exit(1);
}
/* any thresholding ? */
if (Opt->DoThreshold > SUMA_NO_THRESH) {
nt = SUMA_DsetCol2Float(dset, Opt->tind, 0);
if (!nt) {
SUMA_S_Err("Failed to find threshold column");
exit(1);
}
cnt = 0;
if (Opt->DoThreshold == SUMA_LESS_THAN) {
if (Opt->update)
fprintf( SUMA_STDERR,
"%s: Thresholding at %f...\n", FuncName, Opt->ThreshR[0]);
for (i=0;i<N_ni; ++i) {
if (nt[i] >= Opt->ThreshR[0]) {
ni[cnt] = ni[i];
nv[cnt] = nv[i];
++cnt;
}
}
} else if (Opt->DoThreshold == SUMA_ABS_LESS_THAN) {
SUMA_LH("ABS Thresholding at %f...", Opt->ThreshR[0]);
for (i=0;i<N_ni; ++i) {
if (fabs(nt[i]) >= Opt->ThreshR[0]) {
ni[cnt] = ni[i];
nv[cnt] = nv[i];
++cnt;
}
}
} else if (Opt->DoThreshold == SUMA_THRESH_INSIDE_RANGE) {
SUMA_LH("Range Thresholding at %f %f...",
Opt->ThreshR[0], Opt->ThreshR[1]);
for (i=0;i<N_ni; ++i) {
if (nt[i] >= Opt->ThreshR[0] && nt[i] <= Opt->ThreshR[1]) {
ni[cnt] = ni[i];
nv[cnt] = nv[i];
++cnt;
}
}
} else if (Opt->DoThreshold == SUMA_THRESH_OUTSIDE_RANGE) {
SUMA_LH("Ex Range Thresholding at %f %f...",
Opt->ThreshR[0], Opt->ThreshR[1]);
for (i=0;i<N_ni; ++i) {
if (nt[i] < Opt->ThreshR[0] || nt[i] > Opt->ThreshR[1]) {
ni[cnt] = ni[i];
nv[cnt] = nv[i];
++cnt;
}
}
} else {
SUMA_S_Err("Not ready for threshold mode of %d", Opt->DoThreshold);
}
N_ni = cnt;
}
if (Opt->update) {
Opt->update = -(N_ni * Opt->update / 100); /* make it negative
before you begin a
clustering operation */
if (LocalHead) {
fprintf( SUMA_STDERR,
"Update parameter, once every %d nodes\n"
"%d nodes to work with.\n",
-(int)Opt->update, N_ni);
}
}
/* make the call */
list = SUMA_FindClusters (SO, ni, nv, N_ni, -1, Opt, NodeArea);
if (!list) {
SUMA_S_Err("Failed in SUMA_FindClusters");
exit(1);
}
if (list->size) {
/* sort the list */
if (!SUMA_Sort_ClustersList (list, Opt->SortMode)) {
SUMA_S_Err("Failed to sort cluster list");
exit(1);
}
}
/* Show the results */
params = SUMA_HistString(FuncName, argc, argv, NULL);
if (Opt->WriteFile) {
if (0) {
/* You can also write a NIML formatted cluster table with */
NI_element *nel=NULL;
int suc; char sbuf[512]={""};
nel = SUMA_SurfClust_list_2_nel(list, 0, params, NULL);
snprintf(sbuf, 510, "file:%s%s.niml.clstbl", Opt->out_prefix, sap);
NEL_WRITE_TXH(nel, sbuf, suc);
NI_free_element(nel); nel=NULL;
}
clustout = fopen(ClustOutName, "w");
if (!clustout) {
fprintf (SUMA_STDERR,
"Error %s:\n"
"Failed to open %s for writing.\n"
"Check permissions.\n",
FuncName, ClustOutName);
exit(1);
}
SUMA_Show_SurfClust_list(list, clustout, 0, params, NULL);
fclose(clustout);clustout = NULL;
} else SUMA_Show_SurfClust_list(list, NULL, 0, params, NULL);
if (!list->size) {
/* nothing left to do, quit */
exit(0);
}
if (Opt->OutROI) {
SUMA_DSET *dset_roi = NULL;
char *ROIprefix = NULL;
char *NameOut = NULL;
sprintf(stmp,"_ClstMsk%s", sap);
ROIprefix = SUMA_append_string(Opt->out_prefix, stmp);
/* Call this function, write out the resultant dset to disk
then cleanup */
dset_roi =
SUMA_SurfClust_list_2_DsetMask(SO, list, Opt->FullROIList, ROIprefix);
if (!dset_roi) {
SUMA_S_Err("NULL dset_roi");
exit(1);
}
if (Opt->prepend_node_index) {/* prepend node index? */
if (!SUMA_InsertDsetNelCol (
dset_roi, "Node Index Copy", SUMA_NODE_INT,
(void *)(dset_roi->inel->vec[0]), NULL ,1, 0)) {
SUMA_S_Err("Failed to insert column");
}
if (LocalHead) SUMA_ShowDset(dset_roi,0, NULL);
}
NameOut = SUMA_WriteDset_s ( ROIprefix, dset_roi, Opt->oform,
THD_ok_overwrite(), 0);
if (!NameOut) { SUMA_SL_Err("Failed to write dataset."); exit(1); }
SUMA_FreeDset((void *)dset_roi); dset_roi = NULL;
if (NameOut) SUMA_free(NameOut); NameOut = NULL;
if (ROIprefix) SUMA_free(ROIprefix); ROIprefix = NULL;
}
if (Opt->OutClustDset) {
SUMA_DSET *dset_clust = NULL;
char *Clustprefix = NULL;
char *NameOut = NULL;
sprintf(stmp,"_Clustered%s", sap);
Clustprefix = SUMA_append_string(Opt->out_prefix, stmp);
/* Call this function, write out the resultant dset to disk
then cleanup */
dset_clust =
SUMA_MaskDsetByClustList( dset, SO, list,
Opt->FullROIList, Clustprefix);
if (!dset_clust) {
SUMA_S_Err("NULL dset_clust");
exit(1);
}
NameOut = SUMA_WriteDset_s ( Clustprefix, dset_clust, Opt->oform,
THD_ok_overwrite(), 0);
if (!NameOut) { SUMA_SL_Err("Failed to write dataset."); exit(1); }
SUMA_FreeDset((void *)dset_clust); dset_clust = NULL;
if (NameOut) SUMA_free(NameOut); NameOut = NULL;
if (Clustprefix) SUMA_free(Clustprefix); Clustprefix = NULL;
}
if (ClustOutName) SUMA_free(ClustOutName); ClustOutName = NULL;
if (list) dlist_destroy(list); SUMA_free(list); list = NULL;
if (ni) SUMA_free(ni); ni = NULL;
if (nv) SUMA_free(nv); nv = NULL;
if (nt) SUMA_free(nt); nt = NULL;
if (Opt->out_prefix) SUMA_free(Opt->out_prefix); Opt->out_prefix = NULL;
if (Opt) SUMA_free_SurfClust_Opt(Opt);
if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL;
if (dset) SUMA_FreeDset((void *)dset); dset = NULL;
if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) {
SUMA_SL_Err("DO Cleanup Failed!");
}
exit(0);
}
int main (int argc,char *argv[])
{ /* Main */
static char FuncName[]= {"SurfQual"};
char *OutName = NULL, ext[5], *prefix = NULL, *shist=NULL;
SUMA_SURFQUAL_OPTIONS *Opt;
int SO_read = -1;
int i, cnt, trouble, consistent = -1, eu = -1, nsi = -1, N_Spec=0;
SUMA_SurfaceObject *SO = NULL;
SUMA_SurfSpecFile *Spec=NULL;
void *SO_name = NULL;
SUMA_Boolean DoConv = NOPE, DoSphQ = NOPE, DoSelfInt = NOPE;
int N_bad_nodes, N_bad_facesets;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
ps = SUMA_Parse_IO_Args(argc, argv, "-i;-t;-spec;-s;-sv;");
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
Opt = SUMA_SurfQual_ParseInput (argv, argc, ps);
if (argc < 2)
{
SUMA_S_Err("Too few options");
usage_SUMA_SurfQual(ps, 0);
exit (1);
}
/* read all surfaces */
Spec = SUMA_IO_args_2_spec(ps, &N_Spec);
if (N_Spec == 0) {
SUMA_S_Err("No surfaces found.");
exit(1);
}
if (N_Spec > 1 ) {
SUMA_S_Err( "Mike, you cannot mix -spec with -i or -t options "
"for specifying surfaces.");
exit(1);
}
if (Spec->N_Surfs < 1) {
SUMA_S_Err("No surfaces");
exit(1);
}
if (Opt->self_intersect) DoSelfInt = YUP;
DoConv = NOPE;
DoSphQ = NOPE;
if (Opt->surftype) {
if (!strcmp(Opt->surftype, "-sphere")) {
DoSphQ = YUP;
} else {
/* Don't complain anymore, maybe winding checking is all users need */
}
}
for (i=0; i < Spec->N_Surfs; ++i) {/* loop to read in surfaces */
/* now identify surface needed */
if (!(SO = SUMA_Load_Spec_Surf_with_Metrics(Spec, i, ps->sv[0], 0))) {
SUMA_S_Err("Failed to load surface .\n");
exit(1);
}
fprintf(SUMA_STDERR,"\nReport for Surface %s\n", SO->Label);
/* do the quality thing based on the Opt->surftype */
if (!Opt->out_prefix) prefix = SUMA_copy_string(SO->Label);
else prefix = SUMA_copy_string (Opt->out_prefix);
/* check the winding */
if (!SUMA_MakeConsistent (SO->FaceSetList, SO->N_FaceSet,
SO->EL, 0, &trouble)) {
SUMA_S_Warn(
"Failed to make sure surface's mesh is consistently wound.\n"
"You should fix the mesh.\n");
consistent = 0;
}
{
int iii=0, isbad=0, ht0;
int *badedge=(int*)SUMA_calloc(SO->N_Node, sizeof(int));
/* check on troubled edges */
while (iii < SO->EL->N_EL) {
ht0 = SO->EL->ELps[iii][1];
/* make sure edge is not part of three triangles, if it is,skip it*/
if (SO->EL->ELps[iii][2] > 2) {
++iii;
fprintf( SUMA_STDERR,
"%s: Bad edge (#%d: %d--%d), \n"
" part of more than 2 triangles, skip it\n",
FuncName, i, SO->EL->EL[iii][0], SO->EL->EL[iii][1]);
++badedge[SO->EL->EL[iii][0]];
++badedge[SO->EL->EL[iii][1]];
isbad = 1;
continue;
}
++iii;
}
if (isbad) {
if (Spec->N_Surfs > 1) {
sprintf(ext,"_%c", 65+i);
OutName = SUMA_append_replace_string (
prefix,
"_BadEdgeNodes.1D.dset",
ext, 0);
} else {
OutName = SUMA_append_string (prefix, "_BadEdgeNodes.1D.dset");
}
SUMA_WRITE_ARRAY_1D(badedge,SO->N_Node,1,OutName);
if (OutName) SUMA_free(OutName);
OutName = NULL;
}
SUMA_free(badedge);
badedge = NULL;
}
if (DoConv) {
float *Cx = NULL;
if (Spec->N_Surfs > 1) {
sprintf(ext,"_%c", 65+i);
OutName = SUMA_append_replace_string
(prefix, "_Conv_detail.1D.dset", ext, 0);
} else {
OutName = SUMA_append_string (prefix, "_Conv_detail.1D.dset");
}
Cx = SUMA_Convexity_Engine ( SO->NodeList, SO->N_Node,
SO->NodeNormList, SO->FN, OutName, NULL);
if (Cx) SUMA_free(Cx);
Cx = NULL;
if (OutName) SUMA_free(OutName);
OutName = NULL;
}
if (DoSphQ) {
if (Spec->N_Surfs > 1) {
sprintf(ext,"_%c", 65+i);
OutName = SUMA_append_string (prefix, ext);
} else {
OutName = SUMA_copy_string (prefix);
}
shist = SUMA_HistString (NULL, argc, argv, NULL);
SUMA_SphereQuality (SO, OutName, shist, &N_bad_nodes, &N_bad_facesets);
if (shist) SUMA_free(shist);
shist = NULL;
if (OutName) SUMA_free(OutName);
OutName = NULL;
}
if (trouble) { /* put winding problem here to make it visible */
fprintf (SUMA_STDERR,"\n");
SUMA_S_Warn(
"Mesh is not consistent, use ConvertSurface's -make_consistent \n"
"option to fix the problem before proceeding further.\n"
"Other results reported by this and other programs\n"
"may be incorrect if mesh is not consistently wound.\n" );
consistent = 0;
} else {
consistent = 1;
fprintf (SUMA_STDERR,"\n");
fprintf (SUMA_STDERR,"Surface is consistently wound\n");
}
{
SUMA_EULER_SO(SO, eu);
fprintf (SUMA_STDERR,"\n");
fprintf(SUMA_STDERR,"Surface Euler Characteristic is: %d\n", eu);
}
if ((SO->EL->min_N_Hosts == 1 || SO->EL->max_N_Hosts == 1)) {
fprintf (SUMA_STDERR,"\n");
fprintf(SUMA_STDERR,
"Warning %s:\n"
" Min/Max number of edge hosting triangles: [%d/%d] \n",
FuncName, SO->EL->min_N_Hosts, SO->EL->max_N_Hosts);
fprintf( SUMA_STDERR,
" You have edges that form a border in the surface.\n");
}
if (SO->EL->min_N_Hosts == 2 && SO->EL->max_N_Hosts == 2) {
fprintf (SUMA_STDERR,"\n");
fprintf(SUMA_STDERR,"Surface is closed and is a 2-manifold.");
}
if (SO->EL->min_N_Hosts > 2 || SO->EL->max_N_Hosts > 2) {
fprintf (SUMA_STDERR,"\n");
fprintf( SUMA_STDERR,
"Warning %s:\n"
"Min/Max number of edge hosting triangles: [%d/%d] \n",
FuncName, SO->EL->min_N_Hosts, SO->EL->max_N_Hosts);
fprintf(SUMA_STDERR,
"Warning %s:\n"
" You have edges that belong to more than two triangles.\n"
" Bad for analysis assuming surface is a 2-manifold.\n",
FuncName);
if (1) {
int iii=0;
fprintf( SUMA_STDERR,
" These edges are formed by the following nodes:\n");
for (iii = 0; iii < SO->EL->N_EL; ++iii) {
if (SO->EL->ELps[iii][2] > 2)
fprintf (SUMA_STDERR,
" %d: Edge [%d %d] shared by %d triangles.\n",
iii+1, SO->EL->EL[iii][0], SO->EL->EL[iii][1] ,
SO->EL->ELps[iii][2] );
}
}
}
if (DoSelfInt) {
int iii;
FILE *fout=NULL;
byte *report = (byte *)SUMA_calloc(SO->N_Node, sizeof(byte));
if (!report) {
SUMA_SL_Crit("Failed to allocate for report");
report = NULL;
}
fprintf( SUMA_STDERR, "\n\nChecking for intersections...:\n");
nsi = SUMA_isSelfIntersect(SO, 500, report);
if (nsi) {
fprintf( SUMA_STDERR,
" Surface is self intersecting.\n"
"%d segments were found to intersect the surface.\n", nsi);
if (nsi >= 500) {
fprintf( SUMA_STDERR,
" It is possible that you have additional segments"
" intersecting the surface.\n");
}
if (report) {
if (Spec->N_Surfs > 1) {
sprintf(ext,"_%c", 65+i);
OutName = SUMA_append_replace_string ( prefix,
"_IntersNodes.1D.dset",
ext, 0);
} else {
OutName = SUMA_append_string (prefix, "_IntersNodes.1D.dset");
}
fout = fopen(OutName, "w");
if (fout) {
fprintf(fout,
"#List of nodes that are part of segments which intersect "
"the surface\n"
"#%s\n"
"#A total of %d segments (search limit is 500) were found to "
"intersect the surface.\n"
"#Col.1 : Node index\n"
"#Col.2 : Dummy flag, always 1\n",
SUMA_CHECK_NULL_STR(SO->Label), nsi );
for (iii=0; iii<SO->N_Node; ++iii)
if (report[iii]) fprintf(fout, "%d\t1\n", iii);
fclose(fout);
fout = NULL;
} else {
SUMA_SL_Err("Failed to open file for output.");
}
if (OutName) SUMA_free(OutName);
}
} else {
fprintf(SUMA_STDERR, " Surface is not self intersecting.\n");
}
if (report) SUMA_free(report);
report = NULL;
}
fprintf (SUMA_STDERR,"\n");
if (Opt->DoSum) { /* do not change syntax, scripts depend on this */
fprintf(stdout,"Summary for %s:\n", SO->Label);
fprintf(stdout,"Euler_Charac. %d\n", eu);
fprintf(stdout,"Consistent_Winding %d\n", consistent);
if (DoSphQ) {
fprintf(stdout,"Folding_Triangles %d\n", N_bad_facesets);
fprintf(stdout,"Sketchy_nodes %d\n", N_bad_nodes);
}
if (DoSelfInt)
fprintf(stdout,"Self_Intersections %d\n", nsi);
fprintf(stdout,"\n");
}
}
SUMA_LH("clean up");
if (!SUMA_FreeSpecFields(Spec)) {
SUMA_S_Err("Failed to free spec fields");
}
SUMA_free(Spec);
Spec = NULL;
if (prefix) SUMA_free(prefix);
prefix = NULL;
if (Opt->out_prefix) SUMA_free(Opt->out_prefix);
Opt->out_prefix = NULL;
if (Opt) SUMA_free(Opt);
if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) {
SUMA_SL_Err("DO Cleanup Failed!");
}
if (!SUMA_Free_CommonFields(SUMAg_CF))
SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1);
SUMA_RETURN(0);
}
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"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[]={"ConvexHull"};
int i, i3, nspec = 0;
void *SO_name=NULL;
SUMA_SurfaceObject *SO = NULL;
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt;
char stmp[200];
SUMA_Boolean exists = NOPE;
SUMA_Boolean LocalHead = NOPE;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
ps = SUMA_Parse_IO_Args(argc, argv, "-o;-i;-sv;");
if (argc < 2) {
usage_SUMA_ConvexHull(ps);
exit (1);
}
Opt = SUMA_ConvexHull_ParseInput (argv, argc, ps);
SO_name = SUMA_Prefix2SurfaceName(Opt->out_prefix, NULL, NULL,
Opt->SurfFileType, &exists);
if (exists && !THD_ok_overwrite()) {
SUMA_S_Err("Output file(s) %s* on disk.\nWill not overwrite.\n",
Opt->out_prefix);
exit(1);
}
if (Opt->obj_type < 0) {
if (Opt->in_name) {
if (Opt->debug) {
SUMA_S_Note("Creating mask...");
}
if (!SUMA_Get_isosurface_datasets (Opt)) {
SUMA_SL_Err("Failed to get data.");
exit(1);
}
if (Opt->debug > 1) {
if (Opt->debug == 2) {
FILE *fout=fopen("inmaskvec.1D","w");
SUMA_S_Note("Writing masked values...\n");
if (!fout) {
SUMA_SL_Err("Failed to write maskvec");
exit(1);
}
fprintf(fout, "#Col. 0 Voxel Index\n"
"#Col. 1 Is a mask (all values here should be 1)\n" );
for (i=0; i<Opt->nvox; ++i) {
if (Opt->mcdatav[i]) {
fprintf(fout,"%d %.2f\n", i, Opt->mcdatav[i]);
}
}
fclose(fout); fout = NULL;
} else {
FILE *fout=fopen("maskvec.1D","w");
SUMA_S_Note("Writing all mask values...\n");
if (!fout) {
SUMA_S_Err("Failed to write maskvec");
exit(1);
}
fprintf(fout, "#Col. 0 Voxel Index\n"
"#Col. 1 Is in mask ?\n" );
for (i=0; i<Opt->nvox; ++i) {
fprintf(fout,"%d %.2f\n", i, Opt->mcdatav[i]);
}
fclose(fout); fout = NULL;
}
}
} else if (Opt->in_1D) {
MRI_IMAGE *im = NULL;
float *far=NULL;
int nx2;
/* load the 1D file */
im = mri_read_1D (Opt->in_1D);
if (!im) {
SUMA_S_Err("Failed to read file");
exit(1);
}
far = MRI_FLOAT_PTR(im);
if (im->nx == 0) {
fprintf(SUMA_STDERR,"Error %s:\n Empty file %s.\n", FuncName, Opt->in_1D);
exit(1);
}
if (im->ny != 3) {
fprintf(SUMA_STDERR,"Error %s:\n Found %d columns in %s. Expecting 3\n", FuncName, im->ny, Opt->in_1D);
exit(1);
}
/* copy the columns */
Opt->N_XYZ = im->nx;
Opt->XYZ = (float *)SUMA_malloc(im->nx*im->ny*sizeof(float));
if (!Opt->XYZ) {
SUMA_S_Crit("Failed to allocate.");
exit(1);
}
nx2 = 2*im->nx;
for (i=0;i<Opt->N_XYZ; ++i) {
i3 = 3*i;
Opt->XYZ[i3 ] = far[i];
Opt->XYZ[i3+1] = far[i+im->nx];
Opt->XYZ[i3+2] = far[i+nx2];
}
/* done, clean up and out you go */
if (im) mri_free(im); im = NULL;
} else if (ps->i_N_surfnames) {
SUMA_SurfSpecFile *Spec=NULL;
SUMA_SurfaceObject *SO=NULL;
if (ps->i_N_surfnames > 1) {
SUMA_S_Err("Only 1 input surface allowed!");
exit(1);
}
Spec = SUMA_IO_args_2_spec(ps, &nspec);
if (!Spec) {
SUMA_S_Err("Failed to create spec!");
exit(1);
}
if (nspec != 1) {
SUMA_S_Warn("Expected one spec and nothing else");
}
/* load the surface object */
SO = SUMA_Load_Spec_Surf(Spec, 0, ps->sv[0], 0);
if (!SO) {
SUMA_S_Err("Failed to read surface.");
exit(1);
}
/* transfer coords */
if(SO->NodeDim != 3) {
SUMA_S_Err("bad node coords.");
exit(1);
}
Opt->N_XYZ = SO->N_Node;
Opt->XYZ = (float *)SUMA_malloc(SO->N_Node * SO->NodeDim * sizeof(float));
if (!Opt->XYZ) {
SUMA_S_Crit("Failed to allocate.");
exit(1);
}
for (i=0;i<SO->NodeDim*SO->N_Node; ++i) Opt->XYZ[i] = SO->NodeList[i];
if (nspec) {
int k=0;
for (k=0; k<nspec; ++k) {
if (!SUMA_FreeSpecFields(&(Spec[k]))) { SUMA_S_Err("Failed to free spec fields"); }
}
SUMA_free(Spec); Spec = NULL; nspec = 0;
}
if (SO) SUMA_Free_Surface_Object(SO); SO = NULL;
} else {
SUMA_S_Err("No input!");
exit(1);
}
} else {
SUMA_S_Err("Bad input!");
exit(1);
}
/* Now call Marching Cube functions */
if (!(SO = SUMA_ConvexHullSurface(Opt))) {
SUMA_S_Err("Failed to create surface.\n");
exit(1);
}
/* write the surface to disk */
if (!SUMA_Save_Surface_Object (SO_name, SO,
Opt->SurfFileType, Opt->SurfFileFormat, NULL)) {
fprintf (SUMA_STDERR,
"Error %s: Failed to write surface object.\n", FuncName);
exit (1);
}
if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL;
if (Opt->fvec) SUMA_free(Opt->fvec); Opt->fvec = NULL;
if (Opt->mcdatav) {SUMA_free(Opt->mcdatav); Opt->mcdatav = NULL;}
if (Opt->in_vol) { DSET_delete( Opt->in_vol); Opt->in_vol = NULL;}
if (Opt->out_prefix) SUMA_free(Opt->out_prefix); Opt->out_prefix = NULL;
if (Opt->XYZ) SUMA_free(Opt->XYZ); Opt->XYZ = NULL;
if (Opt) SUMA_free(Opt);
if (!SUMA_Free_Displayable_Object_Vect (SUMAg_DOv, SUMAg_N_DOv)) {
SUMA_SL_Err("DO Cleanup Failed!");
}
if (SO_name) SUMA_free(SO_name); SO_name = NULL;
if (!SUMA_Free_CommonFields(SUMAg_CF)) SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1);
exit(0);
}
