void *Seg_NI_read_file(char *fname) {
static char FuncName[]={"Seg_NI_read_file"};
char *niname = NULL;
NI_stream ns = NULL;
void *nel=NULL;
SUMA_ENTRY;
niname = (char *)SUMA_malloc(sizeof(char)*(strlen(fname)+10));
sprintf(niname,"file:%s",fname);
if (!(ns = NI_stream_open(niname, "r"))) {
SUMA_S_Errv("Failed to open steam %s\n", niname);
SUMA_free(niname);
SUMA_RETURN(nel);
}
nel = NI_read_element(ns,1);
NI_stream_close( ns ) ; ns = NULL;
SUMA_free(niname);
SUMA_RETURN(nel);
}
int Seg_CheckOpts(SEG_OPTS *Opt)
{
static char FuncName[]={"Seg_CheckOpts"};
SUMA_ENTRY;
if( ! THD_is_directory(Opt->proot) ){
if( mkdir( Opt->proot , THD_MKDIR_MODE ) != 0 ){
SUMA_S_Errv("Failed to create %s\n", Opt->proot);
exit(1);
}
}
/* Fix VoxDbg */
if (Opt->VoxDbg >= 0) {
Vox1D2Vox3D(Opt->VoxDbg,
DSET_NX(Opt->aset), DSET_NX(Opt->aset)*DSET_NY(Opt->aset),
Opt->VoxDbg3);
} else if (Opt->VoxDbg3[0]>=0) {
Opt->VoxDbg = Opt->VoxDbg3[0] + Opt->VoxDbg3[1]*DSET_NX(Opt->aset) +
Opt->VoxDbg3[2]*DSET_NX(Opt->aset)*DSET_NY(Opt->aset);
}
SUMA_set_SegFunc_debug( Opt->debug, Opt->VoxDbg, Opt->VoxDbg3,
Opt->VoxDbgOut);
SUMA_RETURN(1);
}
THD_3dim_dataset *Seg_load_dset_eng( char *set_name, char *view )
{
static char FuncName[]={"Seg_load_dset_eng"};
THD_3dim_dataset *dset=NULL, *sdset=NULL;
int i=0;
byte make_cp=0;
int verb=0;
char sprefix[THD_MAX_PREFIX+10], *stmp=NULL;
SUMA_ENTRY;
dset = THD_open_dataset( set_name );
if( !ISVALID_DSET(dset) ){
fprintf(stderr,"**ERROR: can't open dataset %s\n",set_name) ;
SUMA_RETURN(NULL);
}
DSET_mallocize(dset) ; DSET_load(dset);
for (i=0; i<DSET_NVALS(dset); ++i) {
if (DSET_BRICK_TYPE(dset,i) != MRI_short) {
if (verb) INFO_message("Sub-brick %d in %s not of type short.\n"
"Creating new short copy of dset ",
i, DSET_PREFIX(dset));
make_cp=1; break;
}
}
if (make_cp) {
if (!SUMA_ShortizeDset(&dset, -1.0)) {
SUMA_S_Err("**ERROR: Failed to shortize");
SUMA_RETURN(NULL);
}
}
if (DSET_IS_MASTERED(dset)) {
if (verb) INFO_message("Dset is mastered, making copy...");
stmp = SUMA_ModifyName(set_name, "append", ".cp", NULL);
sdset = dset;
dset = EDIT_full_copy(sdset, stmp);
free(stmp); DSET_delete(sdset); sdset = NULL;
}
if (view) {
if (view) {
if (!strstr(view,"orig"))
EDIT_dset_items(dset,ADN_view_type, VIEW_ORIGINAL_TYPE, ADN_none);
else if (!strstr(view,"acpc"))
EDIT_dset_items(dset,ADN_view_type, VIEW_ACPCALIGNED_TYPE, ADN_none);
else if (!strstr(view,"tlrc"))
EDIT_dset_items(dset ,ADN_view_type, VIEW_TALAIRACH_TYPE, ADN_none);
else SUMA_S_Errv("View of %s is rubbish", view);
}
}
SUMA_RETURN(dset);
}
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);
}
/*!
\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);
}
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_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);
}
/*!\**
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[]={"SurfToSurf"};
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_SurfaceObject *SO1=NULL, *SO2 = NULL;
SUMA_SurfSpecFile *Spec = NULL;
SUMA_M2M_STRUCT *M2M = NULL;
int N_Spec=0, *nodeind = NULL, N_nodeind, icol, i, j;
MRI_IMAGE *im = NULL, *im_data=NULL;
int nvec=0, ncol=0, nvec_data=0, ncol_data=0, Nchar=0;
float *far = NULL, *far_data=NULL, *dt = NULL, *projdir=NULL;
char *outname = NULL, *s=NULL, sbuf[100];
void *SO_name = NULL;
FILE *outptr=NULL;
SUMA_Boolean exists = NOPE;
SUMA_INDEXING_ORDER d_order = SUMA_NO_ORDER;
SUMA_STRING *SS=NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
/* Allocate space for DO structure */
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
ps = SUMA_Parse_IO_Args(argc, argv, "-i;-t;-spec;-s;-sv;-o;");
Opt = SUMA_SurfToSurf_ParseInput (argv, argc, ps);
if (argc < 2) {
SUMA_S_Err("Too few options");
usage_SurfToSurf(ps, 0);
exit (1);
}
/* if output surface requested, check on pre-existing file */
if (ps->o_N_surfnames) {
SO_name = SUMA_Prefix2SurfaceName(ps->o_surfnames[0],
NULL, NULL, ps->o_FT[0], &exists);
if (exists) {
fprintf(SUMA_STDERR,
"Error %s:\nOutput file(s) %s* on disk.\n"
"Will not overwrite.\n", FuncName, ps->o_surfnames[0]);
exit(1);
}
}
if (Opt->debug > 2) LocalHead = YUP;
outname = SUMA_append_extension(Opt->out_prefix,".1D");
if (SUMA_filexists(outname) && !THD_ok_overwrite()) {
fprintf(SUMA_STDERR,"Output file %s exists.\n", outname);
exit(1);
}
/* Load the surfaces from command line*/
Spec = SUMA_IO_args_2_spec(ps, &N_Spec);
if (N_Spec != 1) {
SUMA_S_Err( "Multiple spec at input.\n"
"Do not mix surface input types together\n");
exit(1);
}
if (Spec->N_Surfs != 2) {
SUMA_S_Err("2 surfaces expected.");
exit(1);
}
SO1 = SUMA_Load_Spec_Surf(Spec, 0, ps->sv[0], 0);
if (!SO1) {
fprintf (SUMA_STDERR,"Error %s:\n"
"Failed to find surface\n"
"in spec file. \n",
FuncName );
exit(1);
}
if (!SUMA_SurfaceMetrics(SO1, "EdgeList|MemberFace", NULL)) {
SUMA_SL_Err("Failed to create edge list for SO1");
exit(1);
}
if (Opt->fix_winding) {
int orient, trouble;
if (LocalHead)
fprintf(SUMA_STDERR,
"%s: Making sure S1 is consistently orientated\n", FuncName);
if (!SUMA_MakeConsistent (SO1->FaceSetList, SO1->N_FaceSet,
SO1->EL, Opt->debug, &trouble)) {
SUMA_SL_Err("Failed in SUMA_MakeConsistent");
}
if (trouble && LocalHead) {
fprintf(SUMA_STDERR,
"%s: trouble value of %d from SUMA_MakeConsistent.\n"
"Inconsistencies were found and corrected unless \n"
"stderr output messages from SUMA_MakeConsistent\n"
"indicate otherwise.\n", FuncName, trouble);
}
if (LocalHead)
fprintf(SUMA_STDERR,"%s: Checking orientation.\n", FuncName);
orient = SUMA_OrientTriangles (SO1->NodeList, SO1->N_Node,
SO1->FaceSetList, SO1->N_FaceSet,
1, 0, NULL, NULL);
if (orient < 0) {
/* flipping was done, dump the edge list since it is not
automatically updated (should do that in function,
just like in SUMA_MakeConsistent, shame on you)
If you revisit this section, use the newer:
SUMA_OrientSOTriangles
*/
if (SO1->EL) SUMA_free_Edge_List(SO1->EL); SO1->EL = NULL;
if (!SUMA_SurfaceMetrics(SO1, "EdgeList", NULL)) {
SUMA_SL_Err("Failed to create edge list for SO1"); exit(1);
}
/* free normals, new ones needed (Normals should be flipped inside of
SUMA_OrientTriangles! (just like in SUMA_MakeConsistent) ) */
if (SO1->NodeNormList) SUMA_free(SO1->NodeNormList);
SO1->NodeNormList = NULL;
if (SO1->FaceNormList) SUMA_free(SO1->FaceNormList);
SO1->FaceNormList = NULL;
}
if (!orient) {
fprintf(SUMA_STDERR,
"Error %s:\nFailed in SUMA_OrientTriangles\n", FuncName);
}
if (LocalHead) {
if (orient < 0) { SUMA_SL_Note("S1 was reoriented"); }
else { SUMA_SL_Note("S1 was properly oriented"); }
}
}
if (!SO1->NodeNormList || !SO1->FaceNormList) {
SUMA_LH("Node Normals"); SUMA_RECOMPUTE_NORMALS(SO1);
}
if (Opt->NodeDbg >= SO1->N_Node) {
SUMA_SL_Warn( "node_debug index is larger than number "
"of nodes in surface, ignoring -node_debug.");
Opt->NodeDbg = -1;
}
SO2 = SUMA_Load_Spec_Surf(Spec, 1, ps->sv[1], 0);
if (!SO2) {
fprintf (SUMA_STDERR,"Error %s:\n"
"Failed to find surface\n"
"in spec file. \n",
FuncName );
exit(1);
}
if (!SUMA_SurfaceMetrics(SO2, "EdgeList|MemberFace", NULL)) {
SUMA_SL_Err("Failed to create edge list for SO2"); exit(1);
}
if (!SO2->NodeNormList || !SO2->FaceNormList) {
SUMA_LH("Node Normals"); SUMA_RECOMPUTE_NORMALS(SO2);
}
if (LocalHead) {
SUMA_LH("Surf1");
SUMA_Print_Surface_Object(SO1, NULL);
SUMA_LH("Surf2");
SUMA_Print_Surface_Object(SO2, NULL);
}
/* a select list of nodes? */
nodeind = NULL; N_nodeind = 0;
if (Opt->in_nodeindices) {
im = mri_read_1D(Opt->in_nodeindices);
if (!im) { SUMA_SL_Err("Failed to read 1D file of node indices"); exit(1);}
far = MRI_FLOAT_PTR(im);
N_nodeind = nvec = im->nx;
ncol = im->ny;
if (ncol != 1) {
SUMA_SL_Err("More than one column in node index input file."); exit(1);
}
nodeind = (int *)SUMA_calloc(nvec, sizeof(int));
if (!nodeind) { SUMA_SL_Crit("Failed to allocate"); exit(1); }
for (i=0;i<nvec;++i) {
nodeind[i] = (int)far[i];
if (nodeind[i] < 0 || nodeind[i] >= SO1->N_Node) {
fprintf(SUMA_STDERR,
"Error %s:\n"
"A node index of %d was found in input file %s, entry %d.\n"
"Acceptable indices are positive and less than %d\n",
FuncName, nodeind[i], Opt->in_nodeindices, i, SO1->N_Node);
exit(1);
}
}
mri_free(im); im = NULL; /* done with that baby */
}
/* a preset directions vector ?*/
projdir = NULL;
if (Opt->in_1D) {
im = mri_read_1D(Opt->in_1D);
if (!im) {
SUMA_SL_Err("Failed to read 1D file of projection directions"); exit(1);
}
far = MRI_FLOAT_PTR(im);
if (im->ny != 3) {
SUMA_SL_Err("Need three columns in projection directions file.");
exit(1);
}
if (im->nx != SO1->N_Node) {
fprintf(SUMA_STDERR,
"Error %s: You must have a direction for each node in SO1.\n"
"%d directions found but SO1 has %d nodes.\n",
FuncName, im->nx, SO1->N_Node);
exit(1);
}
/* change to row major major and make it match nodeind */
projdir = (float *)SUMA_calloc(SO1->N_Node*3, sizeof(float));
if (!projdir) { SUMA_SL_Crit("Failed to allocate"); exit(1); }
for (i=0; i<SO1->N_Node; ++i) {
projdir[3*i ] = far[i ];
projdir[3*i+1] = far[i+ SO1->N_Node];
projdir[3*i+2] = far[i+2*SO1->N_Node];
}
mri_free(im); im = NULL; /* done with that baby */
}
if (SO_name) {
/* user is interpolating surface coords, check on other input insanity */
if (nodeind) {
fprintf( SUMA_STDERR,
"Error %s: You cannot combine "
"option -o_TYPE with -node_indices", FuncName);
exit(1);
}
if (Opt->in_name) {
fprintf(SUMA_STDERR,
"Error %s: You cannot combine option -o_TYPE with -data",
FuncName);
exit(1);
}
}
/* a 1D file containing data, or Data parameter (for XYZ)? */
if (Opt->Data > 0) {
if (Opt->in_name) {
/* When you are ready to work with dsets, you should
checkout the function morphDsetToStd. It uses M2M */
im_data = mri_read_1D(Opt->in_name);
if (!im_data) {
SUMA_SL_Err("Failed to read 1D file of data"); exit(1);}
far_data = MRI_FLOAT_PTR(im_data);
nvec_data = im_data->nx;
ncol_data = im_data->ny;
if (nvec_data != SO2->N_Node) {
SUMA_SL_Err("Your data file must have one row "
"for each node in surface 2.\n"); exit(1);
}
d_order = SUMA_COLUMN_MAJOR;
} else {
im_data = NULL;
far_data = SO2->NodeList;
nvec_data = SO2->N_Node;
ncol_data = 3;
d_order = SUMA_ROW_MAJOR;
}
} else {
/* just -dset */
}
if (!Opt->s) {
SUMA_LH("Going for the mapping of SO1 --> SO2");
M2M = SUMA_GetM2M_NN( SO1, SO2, nodeind, N_nodeind,
projdir, 0, Opt->NodeDbg, Opt->iopt);
SUMA_S_Notev("Saving M2M into %s\n\n",
Opt->out_prefix);
if (!(SUMA_Save_M2M(Opt->out_prefix, M2M))) {
SUMA_S_Err("Failed to save M2M");
exit(1);
}
} else {
SUMA_S_Notev("Reusing mapping of SO1 --> SO2 from %s\n\n",
Opt->s);
if (!(M2M = SUMA_Load_M2M(Opt->s))) {
SUMA_S_Errv("Failed to load %s\n", Opt->s);
exit(1);
}
}
/* Now show the mapping results for a debug node ? */
if (Opt->NodeDbg >= 0) {
char *s = NULL;
s = SUMA_M2M_node_Info(M2M, Opt->NodeDbg);
fprintf(SUMA_STDERR,"%s: Debug for node %d ([%f, %f, %f])of SO1:\n%s\n\n",
FuncName, Opt->NodeDbg,
SO1->NodeList[3*Opt->NodeDbg],
SO1->NodeList[3*Opt->NodeDbg+1],
SO1->NodeList[3*Opt->NodeDbg+2],
s);
SUMA_free(s); s = NULL;
}
/* Now please do the interpolation */
if (Opt->Data > 0) {
if (Opt->NearestNode > 1)
dt = SUMA_M2M_interpolate( M2M, far_data, ncol_data,
nvec_data, d_order, 0 );
else if (Opt->NearestNode == 1)
dt = SUMA_M2M_interpolate( M2M, far_data, ncol_data,
nvec_data, d_order, 1 );
if (!dt) {
SUMA_SL_Err("Failed to interpolate");
exit(1);
}
} else if (Opt->Data < 0) {
SUMA_DSET *dset=NULL, *dseto=NULL;
char *oname=NULL, *uname=NULL, *s1=NULL, *s2=NULL;
int iform=SUMA_NO_DSET_FORMAT;
if (Opt->NodeDbg>= 0) {
SUMA_S_Notev("Processing dset %s\n", Opt->in_name);
}
iform = SUMA_NO_DSET_FORMAT;
if (!(dset = SUMA_LoadDset_s (Opt->in_name, &iform, 0))) {
SUMA_S_Errv("Failed to load %s\n", Opt->in_name);
exit(1);
}
if (!(dseto = SUMA_morphDsetToStd ( dset, M2M,
Opt->NearestNode == 1 ? 1:0))) {
SUMA_S_Errv("Failed to map %s\n", Opt->in_name);
exit(1);
}
s1 = SUMA_append_string(
SUMA_FnameGet(Opt->in_name,"pa", SUMAg_CF->cwd),
Opt->out_prefix);
s2 = SUMA_RemoveDsetExtension_s(
SUMA_FnameGet(Opt->in_name,"l",SUMAg_CF->cwd),
SUMA_NO_DSET_FORMAT);
uname = SUMA_append_extension(s1,s2);
SUMA_free(s1); SUMA_free(s2);
oname = SUMA_WriteDset_s (uname, dseto, Opt->oform, 1, 1);
if (Opt->NodeDbg>= 0) SUMA_S_Notev("Wrote %s\n", oname);
if (oname) SUMA_free(oname); oname=NULL;
if (uname) SUMA_free(uname); oname=NULL;
if (dseto) SUMA_FreeDset(dseto); dseto = NULL;
if (dset) SUMA_FreeDset(dset); dset = NULL;
}
SUMA_LH("Forming the remaining output");
outptr = fopen(outname,"w");
if (!outptr) {
SUMA_SL_Err("Failed to open file for output.\n");
exit(1);
}
/* first create the header of the output */
SS = SUMA_StringAppend(NULL, NULL);
SS = SUMA_StringAppend_va(SS,
"#Mapping from nodes on surf 1 (S1) to nodes on surf 2 (S2)\n"
"# Surf 1 is labeled %s, idcode:%s\n"
"# Surf 2 is labeled %s, idcode:%s\n",
SO1->Label, SO1->idcode_str, SO2->Label, SO2->idcode_str);
icol = 0;
SS = SUMA_StringAppend_va(SS, "#Col. %d:\n"
"# S1n (or nj): Index of node on S1\n"
, icol);
++icol;
if (Opt->NearestNode > 1) {
SS = SUMA_StringAppend_va(SS,
"#Col. %d..%d:\n"
"# S2ne_S1n: Indices of %d nodes on S2 \n"
"# that are closest neighbors of nj.\n"
"# The first index is that of the node on S2 that is closest \n"
"# to nj. If -1 then these values should be ignored because\n"
"# in such cases, nj's projection failed.\n"
, icol, icol+Opt->NearestNode-1, Opt->NearestNode);
icol += Opt->NearestNode;
SS = SUMA_StringAppend_va(SS,
"#Col. %d..%d:\n"
"# S2we_S1n: Weights assigned to nodes on surf 2 (S2) \n"
"# that are closest neighbors of nj.\n"
, icol, icol+Opt->NearestNode-1, Opt->NearestNode);
icol += Opt->NearestNode;
} else if (Opt->NearestNode == 1) {
SS = SUMA_StringAppend_va(SS,
"#Col. %d:\n"
"# S2ne_S1n: Index of the node on S2 (label:%s idcode:%s)\n"
"# that is the closest neighbor of nj.\n"
"# If -1 then this value should be ignored because\n"
"# nj's projection failed.\n"
, icol, SO2->Label, SO2->idcode_str);
++icol;
}
if (Opt->NearestTriangle) {
SS = SUMA_StringAppend_va(SS,
"#Col. %d:\n"
"# S2t_S1n: Index of the S2 triangle that hosts node nj on S1.\n"
"# In other words, nj's closest projection onto S2 falls on \n"
"# triangle S2t_S1n\n"
"# If -1 then this value should be ignored because \n"
"# nj's projection failed.\n"
, icol);
++icol;
}
if (Opt->ProjectionOnMesh) {
SS = SUMA_StringAppend_va(SS,
"#Col. %d..%d:\n"
"# S2p_S1n: Coordinates of projection of nj onto S2\n"
, icol, icol+2);
icol += 3;
}
if (Opt->DistanceToMesh) {
SS = SUMA_StringAppend_va(SS,
"#Col. %d:\n"
"# Closest distance from nj to S2\n"
, icol);
++icol;
}
if (Opt->NearestNodeCoords) {
SS = SUMA_StringAppend_va(SS,
"#Col. %d .. %d:\n"
"# X Y Z coords of nearest node\n"
, icol, icol+2);
icol += 3;
}
if (Opt->Data > 0) {
if (!Opt->in_name) {
SS = SUMA_StringAppend_va(SS,
"#Col. %d..%d:\n"
"# Interpolation using XYZ coordinates of S2 nodes that neighbor nj\n"
"# (same as coordinates of node's projection onto triangle in S2, \n"
"# if using barycentric interpolation)\n"
, icol, icol+2);
icol += 3;
} else {
SS = SUMA_StringAppend_va(SS,
"#Col. %d..%d:\n"
"# Interpolation of data at nodes on S2 that neighbor nj\n"
"# Data obtained from %s\n"
, icol, icol+ncol_data-1, Opt->in_name); icol += ncol_data;
}
}
s = SUMA_HistString("SurfToSurf", argc, argv, NULL);
SS = SUMA_StringAppend_va(SS,
"#History:\n"
"#%s\n", s); SUMA_free(s); s = NULL;
SUMA_SS2S(SS,s);
fprintf(outptr,"%s\n",s); SUMA_free(s); s = NULL;
/* put headers atop columns */
Nchar = 6; /* if you change this number you'll need to fix formats below */
for (i=0; i<icol; ++i) {
sprintf(sbuf,"#%s", MV_format_fval2(i, Nchar -1));
fprintf(outptr,"%6s ", sbuf);
}
fprintf(outptr,"\n");
/* Now put in the values, make sure you parallel columns above! */
for (i=0; i<M2M->M1Nn; ++i) {
fprintf(outptr,"%6s ", MV_format_fval2(M2M->M1n[i], Nchar));
if (Opt->NearestNode > 0) {
for (j=0; j<Opt->NearestNode; ++j) {
if (j < M2M->M2Nne_M1n[i])
fprintf(outptr,"%6s ",
MV_format_fval2(M2M->M2ne_M1n[i][j], Nchar));
else fprintf(outptr,"%6s ", "-1");
} /* Neighboring nodes */
}
if (Opt->NearestNode > 1) { /* add the weights */
for (j=0; j<Opt->NearestNode; ++j) {
if (j < M2M->M2Nne_M1n[i])
fprintf(outptr,"%6s ",
MV_format_fval2(M2M->M2we_M1n[i][j], Nchar));
else fprintf(outptr,"%6s ", "0.0");
}
}
if (Opt->NearestTriangle) {
fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2t_M1n[i], Nchar));
}
if (Opt->ProjectionOnMesh) {
fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2p_M1n[3*i], Nchar));
fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2p_M1n[3*i+1], Nchar));
fprintf(outptr,"%6s ", MV_format_fval2(M2M->M2p_M1n[3*i+2], Nchar));
}
if (Opt->DistanceToMesh) {
fprintf(outptr,"%6s ", MV_format_fval2(M2M->PD[i], Nchar));
}
if (Opt->NearestNodeCoords) {
float x=0.0,y=0.0,z=0.0;
int n = M2M->M2ne_M1n[i][0];
if (n>0) {
n = n * SO2->NodeDim;
x = SO2->NodeList[n];
y = SO2->NodeList[n+1];
z = SO2->NodeList[n+2];
}
fprintf(outptr,"%6s ", MV_format_fval2(x, Nchar));
fprintf(outptr,"%6s ", MV_format_fval2(y, Nchar));
fprintf(outptr,"%6s ", MV_format_fval2(z, Nchar));
}
if (dt && Opt->Data > 0) {
if (!Opt->in_name) {
fprintf(outptr,"%6s ", MV_format_fval2(dt[3*i], Nchar));
fprintf(outptr,"%6s ", MV_format_fval2(dt[3*i+1], Nchar));
fprintf(outptr,"%6s ", MV_format_fval2(dt[3*i+2], Nchar));
} else { /* Column major business */
for (j=0; j<ncol_data; ++j) {
fprintf(outptr,"%6s ",
MV_format_fval2(dt[i+j*M2M->M1Nn], Nchar)); }
}
}
fprintf(outptr,"\n");
}
/* do they want an output surface ? */
if (SO_name) {
float *tmpfv = NULL;
SUMA_LH("Writing surface");
tmpfv = SO1->NodeList;
SO1->NodeList = dt;
if (!SUMA_Save_Surface_Object (SO_name, SO1,
ps->o_FT[0], ps->o_FF[0], NULL)) {
SUMA_S_Err("Failed to write surface object.\n");
exit (1);
}
SO1->NodeList = tmpfv; tmpfv = NULL;
}
if (N_Spec) {
int k=0;
for (k=0; k<N_Spec; ++k) {
if (!SUMA_FreeSpecFields(&(Spec[k]))) {
SUMA_S_Err("Failed to free spec fields");
}
}
SUMA_free(Spec); Spec = NULL; N_Spec = 0;
}
if (projdir) SUMA_free(projdir); projdir = NULL;
if (SO_name) SUMA_free(SO_name); SO_name = NULL;
if (outptr) fclose(outptr); outptr = NULL;
if (dt) SUMA_free(dt); dt = NULL;
if (s) SUMA_free(s); s = NULL;
if (im_data) mri_free(im_data); im_data = NULL; /* done with the data */
if (nodeind) SUMA_free(nodeind); nodeind = NULL;
if (M2M) M2M = SUMA_FreeM2M(M2M);
if (SO1) SUMA_Free_Surface_Object(SO1); SO1 = NULL;
if (SO2) SUMA_Free_Surface_Object(SO2); SO2 = NULL;
if (Spec) SUMA_free(Spec); Spec = NULL;
if (ps) SUMA_FreeGenericArgParse(ps); ps = NULL;
if (Opt) Opt = SUMA_Free_Generic_Prog_Options_Struct(Opt);
if (!SUMA_Free_CommonFields(SUMAg_CF)) SUMA_error_message(FuncName,"SUMAg_CF Cleanup Failed!",1);
exit(0);
}
/*!
\brief parse the arguments for SurfSmooth program
\param argv (char *)
\param argc (int)
\return Opt (SUMA_SURFCLUST_OPTIONS *) options structure.
To free it, use
SUMA_free(Opt->out_name);
SUMA_free(Opt);
*/
SUMA_SURFCLUST_OPTIONS *SUMA_SurfClust_ParseInput (char *argv[], int argc,
SUMA_GENERIC_ARGV_PARSE *ps)
{
static char FuncName[]={"SUMA_SurfClust_ParseInput"};
SUMA_SURFCLUST_OPTIONS *Opt=NULL;
int kar, i, ind;
char *outname;
SUMA_Boolean brk = NOPE;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
Opt = SUMA_create_SurfClust_Opt("SurfClust");
kar = 1;
outname = NULL;
BuildMethod = SUMA_OFFSETS2_NO_REC;
brk = NOPE;
while (kar < argc) { /* loop accross command ine options */
/*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/
if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) {
usage_SUMA_SurfClust(strlen(argv[kar]) > 3 ? 2:1);
exit (0);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
if (!brk && (strcmp(argv[kar], "-no_cent") == 0)) {
Opt->DoCentrality = 0;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-cent") == 0)) {
Opt->DoCentrality = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-O2") == 0)) {
BuildMethod = SUMA_OFFSETS2;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-O2_NR") == 0)) {
BuildMethod = SUMA_OFFSETS2_NO_REC;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-Oll") == 0)) {
BuildMethod = SUMA_OFFSETS_LL;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-update") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -update \n");
exit (1);
}
Opt->update = atof(argv[kar]);
if (Opt->update < 1 || Opt->update > 100) {
fprintf (SUMA_STDERR,
"-update needs a parameter between "
"1 and 50 (I have %.1f)\n", Opt->update);
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-prefix") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -prefix \n");
exit (1);
}
Opt->oform = SUMA_GuessFormatFromExtension(argv[kar], NULL);
if (Opt->oform == SUMA_NO_DSET_FORMAT) Opt->oform = SUMA_ASCII_NIML;
Opt->out_prefix = SUMA_RemoveDsetExtension_s(argv[kar], Opt->oform);
Opt->WriteFile = YUP;
brk = YUP;
}
#if 0
if (!brk && (strcmp(argv[kar], "-spec") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -spec \n");
exit (1);
}
Opt->spec_file = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-sv") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -sv \n");
exit (1);
}
Opt->sv_name = argv[kar];
brk = YUP;
}
if (!brk && (strncmp(argv[kar], "-surf_", 6) == 0)) {
if (kar + 1>= argc) {
fprintf (SUMA_STDERR, "need argument after -surf_X SURF_NAME \n");
exit (1);
}
ind = argv[kar][6] - 'A';
if (ind < 0 || ind >= SURFCLUST_MAX_SURF) {
fprintf (SUMA_STDERR,
"-surf_X SURF_NAME option is out of range.\n"
"Only %d surfaces are allowed. \n"
"Must start with surf_A for first surface.\n",
SURFCLUST_MAX_SURF);
exit (1);
}
kar ++;
Opt->surf_names[ind] = argv[kar];
Opt->N_surf = ind+1;
brk = YUP;
}
#endif
if (!brk && (strcmp(argv[kar], "-input") == 0)) {
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need 2 arguments after -input \n");
exit (1);
}
Opt->in_name = argv[kar]; kar ++;
/* no need for that one Opt->nodecol = atoi(argv[kar]); kar ++; */
Opt->labelcol = atoi(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-rmm") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -rmm \n");
exit (1);
}
Opt->DistLim = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-in_range") == 0)) {
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need two arguments after -in_range \n");
exit (1);
}
Opt->DoThreshold = SUMA_THRESH_INSIDE_RANGE;
Opt->ThreshR[0] = atof(argv[kar]); ++kar;
Opt->ThreshR[1] = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-ex_range") == 0)) {
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need two arguments after -ex_range \n");
exit (1);
}
Opt->DoThreshold = SUMA_THRESH_OUTSIDE_RANGE;
Opt->ThreshR[0] = atof(argv[kar]); ++kar;
Opt->ThreshR[1] = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-thresh") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -thresh \n");
exit (1);
}
Opt->DoThreshold = SUMA_LESS_THAN;
Opt->ThreshR[0] = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-athresh") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -athresh \n");
exit (1);
}
Opt->DoThreshold = SUMA_ABS_LESS_THAN;
Opt->ThreshR[0] = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-thresh_col") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -thresh_col \n");
exit (1);
}
Opt->tind = atoi(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-amm2") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -amm2 \n");
exit (1);
}
Opt->AreaLim = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-n") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -n \n");
exit (1);
}
Opt->NodeLim = atoi(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-out_roidset") == 0)) {
Opt->OutROI = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-prepend_node_index") == 0)) {
Opt->prepend_node_index = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-out_clusterdset") == 0)) {
Opt->OutClustDset = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-out_fulllist") == 0)) {
Opt->FullROIList = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-sort_none") == 0)) {
Opt->SortMode = SUMA_SORT_CLUST_NO_SORT;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-sort_n_nodes") == 0)) {
Opt->SortMode = SUMA_SORT_CLUST_BY_NUMBER_NODES;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-sort_area") == 0)) {
Opt->SortMode = SUMA_SORT_CLUST_BY_AREA;
brk = YUP;
}
if (!brk && !ps->arg_checked[kar]) {
SUMA_S_Errv("Option %s not understood.\n"
"Try -help for usage\n", argv[kar]);
suggest_best_prog_option(argv[0], argv[kar]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}
/* sanitorium */
if (Opt->DistLim == -1.5f) {
fprintf (SUMA_STDERR, "must use option -rmm \n");
exit(1);
}
if (!Opt->out_prefix) {
Opt->out_prefix =
SUMA_RemoveDsetExtension_s(Opt->in_name, SUMA_NO_DSET_FORMAT);
}
if (Opt->SortMode == SUMA_SORT_CLUST_NOT_SET) {
Opt->SortMode = SUMA_SORT_CLUST_BY_AREA; }
if (BuildMethod == SUMA_OFFSETS2) { SUMA_S_Note("Using Offsets2"); }
else if (BuildMethod == SUMA_OFFSETS_LL) { SUMA_S_Note("Using Offsets_ll"); }
else if (BuildMethod == SUMA_OFFSETS2_NO_REC) {
if (LocalHead) SUMA_S_Note("Using no recursion"); }
else {
SUMA_SL_Err("Bad BuildMethod");
exit(1);
}
SUMA_SurfClust_Set_Method(BuildMethod);
if (Opt->FullROIList && !(Opt->OutROI || Opt->OutClustDset)) {
SUMA_SL_Err("-out_fulllist must be used in conjunction "
"with -out_ROIdset or -out_clusterdset");
exit(1);
}
SUMA_RETURN(Opt);
}
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"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 */
/*!
A function to call SUMA_qhull_wrap or SUMA_qdelaunay_wrap
*/
SUMA_SurfaceObject *SUMA_ConvexHullSurface(
SUMA_GENERIC_PROG_OPTIONS_STRUCT * Opt)
{
static char FuncName[]={"SUMA_ConvexHullSurface"};
SUMA_SurfaceObject *SO=NULL;
float *xyz=NULL, *xyzp=NULL, *txyz=NULL;
int npt, *ijk=NULL, nf=0, cnt, i, j, k, nxx, nyy, nzz,N_txyz=-1;
FILE *fid=NULL;
THD_fvec3 fv, iv;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
npt = 0;
N_txyz=-1;
if (Opt->UseThisBrain) {
MRI_IMAGE *im = NULL;
float *far=NULL;
int nx2, i3;
/* load the 1D file */
im = mri_read_1D (Opt->UseThisBrain);
if (!im) {
SUMA_S_Err("Failed to read file");
SUMA_RETURN(NULL);
}
far = MRI_FLOAT_PTR(im);
if (im->nx == 0) {
SUMA_S_Errv("Empty file %s.\n", Opt->UseThisBrain);
SUMA_RETURN(NULL);
}
if (im->ny != 3) {
SUMA_S_Errv("Found %d columns in %s. Expecting 3\n",
im->ny, Opt->UseThisBrain);
SUMA_RETURN(NULL);
}
/* copy the columns */
N_txyz = im->nx;
txyz = (float *)SUMA_malloc(im->nx*im->ny*sizeof(float));
if (!txyz) {
SUMA_S_Crit("Failed to allocate.");
SUMA_RETURN(NULL);
}
nx2 = 2*im->nx;
for (i=0; i<N_txyz; ++i) {
i3 = 3*i;
txyz[i3 ] = far[i];
txyz[i3+1] = far[i+im->nx];
txyz[i3+2] = far[i+nx2];
}
/* done, clean up and out you go */
if (im) mri_free(im); im = NULL;
}
if (Opt->in_vol) {
cnt = 0; npt = 0;
nxx = (DSET_NX(Opt->in_vol));
nyy = (DSET_NY(Opt->in_vol));
nzz = (DSET_NZ(Opt->in_vol));
if (Opt->debug) fprintf(SUMA_STDERR,"%s:\nRunning qhull...\n", FuncName);
xyz = (float *)SUMA_malloc(3*nxx*nyy*nzz*sizeof(float));
if (!xyz) {
SUMA_S_Err("Failed to allocate"); SUMA_RETURN(NULL);
}
for( k = 0 ; k < nzz ; k++ ) {
for( j = 0 ; j < nyy ; j++ ) {
for( i = 0 ; i < nxx ; i++ ) {
if (Opt->mcdatav[cnt] == 1) {
fv.xyz[0] = DSET_XORG(Opt->in_vol) + i * DSET_DX(Opt->in_vol);
fv.xyz[1] = DSET_YORG(Opt->in_vol) + j * DSET_DY(Opt->in_vol);
fv.xyz[2] = DSET_ZORG(Opt->in_vol) + k * DSET_DZ(Opt->in_vol);
/* change mm to RAI coords */
iv = SUMA_THD_3dmm_to_dicomm( Opt->in_vol->daxes->xxorient,
Opt->in_vol->daxes->yyorient,
Opt->in_vol->daxes->zzorient,
fv );
xyz[3*npt] = iv.xyz[0];
xyz[3*npt+1] = iv.xyz[1]; xyz[3*npt+2] = iv.xyz[2];
npt++;
}
++cnt;
}
}
}
} else if (Opt->XYZ) {
xyz = (float *)SUMA_malloc(3*Opt->N_XYZ*sizeof(float));
if (!xyz) {
SUMA_S_Err("Failed to allocate"); SUMA_RETURN(NULL);
}
for( k = 0 ; k < 3*Opt->N_XYZ ; k++ ) {
xyz[k] = Opt->XYZ[k]; npt = Opt->N_XYZ;
}
} else {
SUMA_S_Err("No input");
goto CLEANUP;
}
if (Opt->corder) {
SUMA_PC_XYZ_PROJ *pcp=NULL;
if (Opt->geom==1) {
SUMA_S_Warn("PCA projection makes no sense for usual convex hull");
}
if (!(pcp = SUMA_Project_Coords_PCA (xyz, npt, npt/2, NULL,
E3_PLN_PRJ, ROT_2_Z,0))) {
SUMA_S_Err("Failed to project");
goto CLEANUP;
}
xyzp = pcp->xyzp; pcp->xyzp = NULL;
pcp = SUMA_Free_PC_XYZ_Proj(pcp);
} else {
xyzp = xyz;
}
if (N_txyz >= 0 && N_txyz != npt) {
SUMA_S_Errv("Mismatch between number of coordinates for convex hull\n"
"and number of coordinates to adopt in the end.\n"
" %d, versus %d in -these_coords\n",
npt, N_txyz);
goto CLEANUP;
}
if (Opt->geom == 1) { /* convex hull */
if (! (nf = SUMA_qhull_wrap(npt, xyzp, &ijk, 1, Opt->s)) ) {
fprintf(SUMA_STDERR,"%s:\nFailed in SUMA_qhull_wrap\n", FuncName);
goto CLEANUP;
}
/* Other than unif==0 make no sense here, but leave it to the user */
switch (Opt->unif) {
case 0: /* coordinates as passed to qhull,
could be projected ones*/
SO = SUMA_Patch2Surf(xyzp, npt, ijk, nf, 3);
break;
case 1: /* Original corrdinates passed to qhull
(pre-projections, if any) */
SO = SUMA_Patch2Surf(xyz, npt, ijk, nf, 3);
break;
case 2: /* special coordinates passed by user,
never passed in any form to qhull */
SUMA_S_Warn("Makes no sense to mess with coords for convex hull...");
SO = SUMA_Patch2Surf(txyz, npt, ijk, nf, 3);
break;
default:
SUMA_S_Err("pit of despair");
goto CLEANUP;
}
if (Opt->debug) fprintf(SUMA_STDERR,"%s:\n%d triangles.\n", FuncName, nf);
} else if (Opt->geom == 2) { /* triangulation */
if (! (nf = SUMA_qdelaunay_wrap(npt, xyzp, &ijk, 1, Opt->s)) ) {
fprintf(SUMA_STDERR,"%s:\nFailed in SUMA_qdelaunay_wrap\n", FuncName);
goto CLEANUP;
}
switch (Opt->unif) {
case 0: /* coordinates as passed to qdelaunay,
could be projected ones*/
if (xyz == xyzp) xyz=NULL; /* xyzp will be set to
null in next call,
so xyz is treated
the same here */
SO = SUMA_NewSO(&xyzp, npt, &ijk, nf, NULL);
SUMA_LHv("xyzp %p, ijk %p\n", txyz, ijk);
break;
case 1: /* Original corrdinates passed to qdelaunay
(pre-projections, if any) */
SO = SUMA_NewSO(&xyz, npt, &ijk, nf, NULL);
SUMA_LHv("xyz %p, ijk %p\n", txyz, ijk);
break;
case 2: /* special coordinates passed by user,
never passed in any form to qdelaunay */
SO = SUMA_NewSO(&txyz, npt, &ijk, nf, NULL);
SUMA_LHv("txyz %p, ijk %p\n", txyz, ijk);
break;
default:
SUMA_S_Err("pit of despair, again");
goto CLEANUP;
}
} else {
SUMA_S_Errv("Opt->geom = %d not valid\n", Opt->geom);
goto CLEANUP;
}
CLEANUP:
if (ijk) SUMA_free(ijk); ijk=NULL;
if(txyz) SUMA_free(txyz); txyz=NULL;
if (xyzp != xyz && xyzp != NULL) SUMA_free(xyzp); xyzp = NULL;
if (xyz) SUMA_free(xyz); xyz = NULL;
SUMA_RETURN(SO);
}
/*!
\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);
}
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"SurfInfo"};
SUMA_GENERIC_PROG_OPTIONS_STRUCT *Opt;
SUMA_GENERIC_ARGV_PARSE *ps=NULL;
SUMA_SurfSpecFile *Spec = NULL;
int i, N_Spec;
char *s = NULL;
SUMA_SurfaceObject *SO=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_SurfInfo(ps);
exit (1);
}
Opt = SUMA_SurfInfo_ParseInput (argv, argc, ps);
if (Opt->debug > 2) LocalHead = YUP;
if (ps->s_N_surfnames + ps->i_N_surfnames + ps->t_N_surfnames != 1) {
SUMA_S_Err("Multiple surface specifications used. "
"Only one surface allowed.");
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);
}
SUMA_LH("Loading surface...");
SO = SUMA_Load_Spec_Surf(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 (Opt->b1) {
SUMA_LH("Calculating all metrics, be patient...");
/* calc trimmings */
if (!SUMA_SurfaceMetrics_eng(SO, "Convexity|EdgeList|PolyArea|Curvature|"
"EdgeList|MemberFace|CheckWind",
NULL, Opt->debug, SUMAg_CF->DsetList)) {
fprintf (SUMA_STDERR,
"Error %s: Failed in SUMA_SurfaceMetrics.\n", FuncName);
}
}
if (!Opt->s) { /* the whole thing */
SUMA_Print_Surface_Object(SO, stdout);
} else { /* just the specifics */
char *s=NULL;
i = 0;
while ( (s=SUMA_NI_get_ith_string(Opt->s,"|",i) ) ) {
if (!strcmp(s,"N_Node")) {
if (Opt->b2) {
if (i) fprintf(SUMA_STDOUT, "%s%d", Opt->in_1D, SO->N_Node);
else fprintf(SUMA_STDOUT, "%d", SO->N_Node);
} else {
if (i) fprintf(SUMA_STDOUT, "%s%s=%d", Opt->in_1D, s, SO->N_Node);
else fprintf(SUMA_STDOUT, "%s=%d", s, SO->N_Node);
}
} else if (!strcmp(s,"N_Tri") || !strcmp(s,"N_FaceSet")) {
if (Opt->b2) {
if (i) fprintf(SUMA_STDOUT, "%s%d", Opt->in_1D, SO->N_FaceSet);
else fprintf(SUMA_STDOUT, "%d", SO->N_FaceSet);
} else {
if (i) fprintf(SUMA_STDOUT, "%s%s=%d",
Opt->in_1D, s, SO->N_FaceSet);
else fprintf(SUMA_STDOUT, "%s=%d", s, SO->N_FaceSet);
}
} else if (!strcmp(s,"COM")) {
if (Opt->b2) {
if (i) fprintf(SUMA_STDOUT, "%s%f %f %f",
Opt->in_1D,
SO->Center[0], SO->Center[1],SO->Center[2]);
else fprintf(SUMA_STDOUT, "%f %f %f",
SO->Center[0], SO->Center[1],SO->Center[2]);
} else {
if (i) fprintf(SUMA_STDOUT, "%s%s=%f %f %f",
Opt->in_1D, s,
SO->Center[0], SO->Center[1],SO->Center[2]);
else fprintf(SUMA_STDOUT, "%s=%f %f %f", s,
SO->Center[0], SO->Center[1],SO->Center[2]);
}
} else {
SUMA_S_Errv("Don't know about parameter >>%s<<\n", s);
exit(1);
}
SUMA_free(s);
++i;
}
fprintf(SUMA_STDOUT,"\n");
}
if (SO) SUMA_Free_Surface_Object(SO); SO = 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);
}
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);
}
int SUMA_SegEngine(SEG_OPTS *Opt)
{
static char FuncName[]={"SUMA_SegEngine"};
THD_3dim_dataset *pygcbo=NULL;
int iter=0, kk, UseK[500];
char sinf[256];
char sreport[512]={"unset_report_name.txt"};
SUMA_Boolean LocalHead = YUP;
SUMA_ENTRY;
#ifdef USE_OMP
#pragma omp parallel
{
if( LocalHead && omp_get_thread_num() == 0 )
INFO_message("OpenMP thread count = %d",omp_get_num_threads()) ;
}
#endif
if (Opt->cset) {/* Hide Classes not for analysis */
int mm;
short *sc=NULL;
sc= (short *)DSET_ARRAY (Opt->cset, 0);
for (kk=0 ; kk<DSET_NVOX(Opt->cset); ++kk) {
for (mm=0; mm<Opt->cs->N_label; ++mm) {
if (sc[kk] == Opt->cs->keys[mm]) break;
}
if (mm >= Opt->cs->N_label) sc[kk] = 0;
}
} else {
SUMA_S_Err("Need cset");
SUMA_RETURN(0);
}
if (!Opt->priCgALL) {
if ((Opt->priCgA || Opt->priCgL)) {
if (!SUMA_MergeCpriors( Opt->cs, Opt->cmask, Opt->aset,
Opt->priCgA, Opt->wA,
Opt->priCgL, Opt->wL,
&Opt->priCgALL, Opt)) {
SUMA_S_Err("NULL Opt->priCgALL");
SUMA_RETURN(0);
}
} else if ((Opt->priCgLname && !strcmp(Opt->priCgLname,"INIT_MIXFRAC")) ||
(Opt->priCgAname && !strcmp(Opt->priCgAname,"INIT_MIXFRAC")) ){
SUMA_S_Note("Forcing spatial priors at initial mixing fraction");
if (!SUMA_MergeCpriors( Opt->cs, Opt->cmask, Opt->aset,
NULL, 0.0,
NULL, 0.0,
&Opt->priCgALL, Opt)) {
SUMA_S_Err("NULL Opt->priCgALL");
SUMA_RETURN(0);
}
}
if (Opt->priCgALL && Opt->debug > 1) {
SUMA_Seg_Write_Dset(Opt->proot,"priCgALLmerged",
Opt->priCgALL, -1, Opt->hist);
}
}
/* split the classes */
if (Opt->Split) {
THD_3dim_dataset *Scset=NULL;
int N_split=0;
SUMA_CLASS_STAT *Scs=NULL;
SUMA_S_Warn("Splitting classes");
while (Opt->Split[N_split] > 0) ++N_split;
if (N_split != Opt->cs->N_label) {
SUMA_S_Errv("Split vector malformed.\n"
"Have %d values in Split, but %d classes\n",
N_split, Opt->cs->N_label);
SUMA_RETURN(0);
}
if (!SUMA_Split_Classes(Opt->cs->label, Opt->cs->N_label, Opt->cs->keys,
Opt->Split, Opt->aset, Opt->cset, Opt->cmask,
&Scset, &Scs, Opt)) {
SUMA_S_Err("Failed to split classes");
SUMA_RETURN(0);
}
/* Save old class stats and replace by split classes */
Opt->Gcs = Opt->cs; Opt->cs = Scs; Scs=NULL;
DSET_delete(Opt->cset); Opt->cset = Scset; Scset=NULL;
}
/* get the initial parameters pstCgALL is still null here normally
and priCgALL will not be used when that is the case.
So these estimates are from cset alone */
if (!SUMA_Class_stats( Opt->aset, Opt->cset, Opt->cmask, Opt->cmask_count,
Opt->pstCgALL, Opt->priCgALL, Opt->gold,
Opt->cs, Opt->mix_frac_floor)) {
SUMA_S_Err("Failed in class stats");
SUMA_RETURN(0);
}
if (Opt->debug) SUMA_show_Class_Stat(Opt->cs, "Class Stat At Input:\n", NULL);
/* Make sure there are good estimates for all classes */
if (SUMA_ZeroSamp_from_ClassStat(Opt->cs)) {
if (!Opt->debug)
SUMA_show_Class_Stat(Opt->cs, "Class Stat At Input:\n", NULL);
SUMA_S_Err("Have empty classes at initialization. Not cool\n");
SUMA_RETURN(0);
}
if (!Opt->pstCgALL) { /* Compute initial posterior distribution */
if (!(SUMA_pst_C_giv_ALL(Opt->aset,
Opt->cmask, Opt->cmask_count,
Opt->cs, Opt->priCgALL, Opt->pCgN,
Opt->B, Opt->T,
(!Opt->mixopt || strcmp(Opt->mixopt,"IGNORE")) ? 1:0,
&Opt->pstCgALL))) {
SUMA_S_Err("Failed in SUMA_pst_C_giv_ALL");
SUMA_RETURN(0);
}
}
if (!SUMA_Class_stats( Opt->aset, Opt->cset, Opt->cmask, Opt->cmask_count,
Opt->pstCgALL, Opt->priCgALL, Opt->gold,
Opt->cs, Opt->mix_frac_floor)) {
SUMA_S_Err("Failed in class stats");
SUMA_RETURN(0);
}
if (Opt->debug)
SUMA_show_Class_Stat(Opt->cs,
"Posterior Weighted Class Stat At Input:\n", NULL);
/* To begin iterations, we should have class stats and pstCgALL.
Also, need an initial cset if B > 0.0 */
for (iter=0; iter<Opt->N_main; ++iter) {
if (Opt->debug) {
INFO_message("Iteration %d memory check:\n",iter);MCHECK;
}
/* improve parameters based on edge energy */
if (Opt->edge) {
double en;
float vv=1.0;
int *UseK, N_kok;
THD_3dim_dataset *skelset=NULL, *l_Bset=NULL, *l_aset=NULL;
NEW_SHORTY(Opt->aset, Opt->cs->N_label*(Opt->cs->N_label-1)/2,
"skelly", skelset);
UseK = (int *)SUMA_calloc(Opt->cs->N_label, sizeof(int));
if ((N_kok = SUMA_Class_k_Selector(Opt->cs, "classes_string",
"CSF; GM; WM", UseK))<0) {
SUMA_S_Err("Failed to find classes");
SUMA_RETURN(0);
}
if (1) {
/* It should be the case that edge energy should not be affected
by the presence of bias field (METH2), for now, I will
pass a constant field here for testing */
NEW_SHORTY(Opt->aset, 1, "l_Bset", l_Bset);
if (!SUMA_InitDset(l_Bset, &vv, 1, Opt->cmask, 1)) {
SUMA_S_Err("Failed to initialize l_Bset");
SUMA_RETURN(0);
}
if (iter == 0) l_aset = Opt->aset;
else l_aset = Opt->xset;
} else { /* old approach */
l_aset = Opt->aset; l_Bset = Opt->Bset;
}
en = SUMA_DsetEdgeEnergy(l_aset, Opt->cset,
Opt->cmask, l_Bset,
skelset, Opt->cs, Opt->edge,
UseK, N_kok);
SUMA_Seg_Write_Dset(Opt->proot, "PreSkel", skelset, iter, Opt->hist);
SUMA_S_Notev("Edge Enenergy, Pre MAP : %f\n", en);
#if 1
if (!SUMA_MAP_EdgeEnergy( l_aset, Opt->cmask, Opt->cmask_count,
l_Bset, Opt->cs,
Opt->cset, Opt->edge,
Opt->priCgALL, Opt->pCgN,
Opt->B, Opt->T, 0.4, 0.4,
Opt)) {
SUMA_S_Err("Failed in MAP_EdgeEnergy");
exit(1);
}
en = SUMA_DsetEdgeEnergy(l_aset, Opt->cset,
Opt->cmask,
l_Bset, skelset, Opt->cs, Opt->edge,
UseK, N_kok);
SUMA_Seg_Write_Dset(Opt->proot, "PstSkel", skelset, iter, Opt->hist);
SUMA_S_Notev("Edge Enenergy, Post MAP : %f\n", en);
#endif
DSET_delete(skelset); skelset=NULL;
if (l_Bset && l_Bset != Opt->Bset) DSET_delete(l_Bset); l_Bset=NULL;
SUMA_ifree(UseK);
}
if (Opt->bias_param > 0) {
if (Opt->debug > 1)
SUMA_S_Notev("Wells Bias field correction, FWHM %f, iteration %d\n",
Opt->bias_param, iter);
if (!strcmp(Opt->bias_meth,"Wells")) {
if (!(SUMA_estimate_bias_field_Wells(Opt, Opt->cmask, Opt->cs,
Opt->bias_param, Opt->bias_classes,
Opt->aset, Opt->pstCgALL,
&Opt->Bset ))) {
SUMA_S_Err("Failed to estimate bias");
SUMA_RETURN(0);
}
} else {
SUMA_S_Errv("Only Wells is allowed for now, have %s\n",
Opt->bias_meth);
SUMA_RETURN(0);
}
if (!(SUMA_apply_bias_field(Opt, Opt->aset, Opt->Bset,
&Opt->xset))) {
SUMA_S_Err("Failed to apply field");
SUMA_RETURN(0);
}
} else {
if (iter == 0) {
if (Opt->debug > 1)
SUMA_S_Note("Skipping bias field correction");
if (!Opt->xset) Opt->xset = EDIT_full_copy(Opt->aset, Opt->xrefix);
if (!Opt->Bset) {
float vv=1.0;
NEW_SHORTY(Opt->aset,1, "ConstantField", Opt->Bset);
if (!SUMA_InitDset(Opt->Bset, &vv, 1, Opt->cmask, 1)) {
SUMA_S_Err("Failed to initialize Bset");
SUMA_RETURN(0);
}
}
}
}
if (Opt->B > 0) {
if (Opt->debug > 1 && iter==0) {
SUMA_Seg_Write_Dset(Opt->proot, "MAPlabel.-1", Opt->cset,
-1, Opt->hist);
}
if (!(SUMA_MAP_labels(Opt->xset, Opt->cmask,
Opt->cs, 6, Opt->priCgALL, &Opt->cset,
&Opt->pCgN, Opt))) {
SUMA_S_Err("Failed in SUMA_MAP_labels");
SUMA_RETURN(0);
}
if (Opt->debug > 1) {
SUMA_Seg_Write_Dset(Opt->proot, "MAPlabel", Opt->cset,
iter, Opt->hist);
SUMA_Seg_Write_Dset(Opt->proot, "pCgN", Opt->pCgN, iter,
Opt->hist);
}
AFNI_FEED(Opt->ps->cs, "MAPlabel", iter, Opt->cset);
}
if (!(SUMA_pst_C_giv_ALL(Opt->xset,
Opt->cmask, Opt->cmask_count,
Opt->cs,
Opt->priCgALL, Opt->pCgN,
Opt->B, Opt->T,
(!Opt->mixopt || strcmp(Opt->mixopt,"IGNORE")) ? 1:0,
&Opt->pstCgALL))) {
SUMA_S_Err("Failed in SUMA_pst_C_giv_ALL");
SUMA_RETURN(0);
}
if (Opt->debug > 1) {
SUMA_Seg_Write_Dset(Opt->proot, "pstCgALL", Opt->pstCgALL,
iter, Opt->hist);
}
if (Opt->B <= 0.0f) { /* no need if B > 0 because cset is
set in SUMA_MAP_labels*/
/* update class based on max(Opt->pstCgALL) */
if (!(SUMA_assign_classes( Opt->pstCgALL, Opt->cs,
Opt->cmask, &Opt->cset))) {
SUMA_S_Err("Failed in assign_classes");
SUMA_RETURN(0);
}
}
/* Now update class stats */
if (!SUMA_Class_stats( Opt->xset, Opt->cset,
Opt->cmask, Opt->cmask_count,
Opt->pstCgALL, Opt->priCgALL, Opt->gold,
Opt->cs, Opt->mix_frac_floor)) {
SUMA_S_Err("Failed in class stats");
SUMA_RETURN(0);
}
if (Opt->debug || Opt->gold || Opt->gold_bias) {
double bad_bias_thresh, bias_bad_count;
char *sbig=NULL;
sprintf(sinf, "Class Stat iter %d:\n", iter+1);
if (iter == Opt->N_main-1 || Opt->debug) {
SUMA_show_Class_Stat(Opt->cs, sinf, NULL);
if (Opt->proot) sprintf(sreport,
"%s/ClassStat.i%02d%s.txt", Opt->proot,
iter+1, (iter==Opt->N_main-1) ? ".FINAL":"");
else snprintf(sreport, 500,
"%s.ClassStat.i%02d%s.txt",
Opt->prefix, iter+1, (iter==Opt->N_main-1) ? ".FINAL":"");
sbig = SUMA_append_replace_string(Opt->hist, sinf,"\n",0);
SUMA_show_Class_Stat(Opt->cs, sbig, sreport);
SUMA_ifree(sbig);
}
/* Report on bias correction */
bad_bias_thresh = 0.06;
if ((Opt->gold_bias && Opt->Bset) &&
(iter == Opt->N_main-1 || Opt->debug)) {
FILE *fout = fopen(sreport,"a");
bias_bad_count = SUMA_CompareBiasDsets(Opt->gold_bias, Opt->Bset,
Opt->cmask, Opt->cmask_count,
bad_bias_thresh, NULL);
SUMA_S_Notev("bad_count at thresh %f = %f%% of mask.\n",
bad_bias_thresh, bias_bad_count);
if (fout) {
fprintf(fout, "bad_count at thresh %f = %f%% of mask.\n",
bad_bias_thresh, bias_bad_count);
fclose(fout); fout = NULL;
}
}
}
}
if (Opt->Split) {
THD_3dim_dataset *Gcset=NULL;
THD_3dim_dataset *GpstCgALL=NULL;
/* need to put things back */
if (!SUMA_Regroup_classes(Opt,
Opt->cs->label, Opt->cs->N_label, Opt->cs->keys,
Opt->Gcs->label, Opt->Gcs->N_label, Opt->Gcs->keys,
Opt->cmask, Opt->pstCgALL, Opt->cset,
&GpstCgALL, &Gcset)) {
}
/* switch dsets */
DSET_delete(Opt->pstCgALL); Opt->pstCgALL = GpstCgALL; GpstCgALL = NULL;
DSET_delete(Opt->cset); Opt->cset = Gcset; Gcset = NULL;
}
SUMA_RETURN(1);
}
int main(int argc, char **argv)
{
static char FuncName[]={"3dSeg"};
SEG_OPTS *Opt=NULL;
char *atr=NULL;
float *mixfrac= NULL;
int i=0;
double ff;
SUMA_SEND_2AFNI SS2A;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
Opt = Seg_Default(argv, argc);
Opt = Seg_ParseInput (Opt,argv, argc);
Opt->hist = tross_commandline( FuncName , argc , argv ) ;
/* load the input data */
if (!(Opt->aset = Seg_load_dset( Opt->aset_name ))) {
SUMA_RETURN(1);
}
if (!Seg_CheckOpts(Opt)) {
SUMA_S_Err("Failed on option check");
SUMA_RETURN(1);
}
/* Load mask dataset */
if (Opt->mset_name) {
if (!strncasecmp(Opt->mset_name,"auto", 4)) {
byte *mm=NULL;
int j;
short *sb=NULL;
if (!(mm = THD_automask(Opt->aset))) {
SUMA_RETURN(1);
}
NEW_SHORTY(Opt->aset, DSET_NVALS(Opt->aset),
"automask.cp", Opt->mset);
sb = (short *)DSET_ARRAY(Opt->mset,0);
for (j=0; j<DSET_NVOX(Opt->mset); ++j) {
sb[j] = (short)mm[j];
}
free(mm); mm=NULL;
} else if (!(Opt->mset = Seg_load_dset( Opt->mset_name ))) {
SUMA_RETURN(1);
}
}
/* reference classes */
if (Opt->gold_name) {
if (!(Opt->gold = Seg_load_dset( Opt->gold_name ))) {
SUMA_RETURN(1);
}
}
if (Opt->gold_bias_name) {
if (!(Opt->gold_bias = Seg_load_dset( Opt->gold_bias_name ))) {
SUMA_RETURN(1);
}
}
if (!Opt->clss) {
SUMA_S_Err("Need -classes option");
SUMA_RETURN(1);
}
/* Talk ? */
if (Opt->ps->cs->talk_suma) {
Opt->ps->cs->istream = SUMA_BRAINWRAP_LINE;
Opt->ps->cs->afni_istream = SUMA_AFNI_STREAM_INDEX2;
if (!SUMA_SendToAfni (Opt->ps->cs, NULL, 0)) {
SUMA_SL_Err("Failed to initialize SUMA_SendToAfni");
Opt->ps->cs->afni_Send = NOPE;
Opt->ps->cs->Send = NOPE;
} else {
/* send in_vol to afni */
SUMA_SL_Note("Sending anat volume to AFNI");
SS2A.dset = Opt->aset; SS2A.at_sb=-1;
if (!SUMA_SendToAfni(Opt->ps->cs, &SS2A, 1)) {
SUMA_SL_Err("Failed to send volume to AFNI");
Opt->ps->cs->afni_Send = NOPE;
}
}
}
/* classified set ? */
if (Opt->this_cset_name) { /* user supplied initializer */
if (!(Opt->cset = Seg_load_dset( Opt->this_cset_name ))) {
SUMA_RETURN(1);
}
}
/* labeltable? */
if (Opt->labeltable_name) {
Dtable *vl_dtable=NULL;
char *labeltable_str=NULL;
int kk=0;
/* read the table */
if (!(labeltable_str = AFNI_suck_file( Opt->labeltable_name))) {
ERROR_exit("Failed to read %s", Opt->labeltable_name);
}
if (!(vl_dtable = Dtable_from_nimlstring(labeltable_str))) {
ERROR_exit("Could not parse labeltable");
}
CLASS_KEYS_FROM_LT(vl_dtable);
destroy_Dtable(vl_dtable); vl_dtable=NULL;
}
if (!Opt->keys) {
Dtable *vl_dtable=NULL;
if (Opt->cset && (vl_dtable = DSET_Label_Dtable(Opt->cset))) {
if (Opt->debug) SUMA_S_Note("Getting keys from -cset dataset");
/* try getting keys from cset */
CLASS_KEYS_FROM_LT(vl_dtable);
/* Do not delete vl_dtable, it is the same pointer in Opt->cset */
} else {
/* add default keys */
if (Opt->debug) SUMA_S_Note("Keys not available, assuming defaults");
Opt->keys = (int *)calloc(Opt->clss->num, sizeof(int));
for (i=0; i<Opt->clss->num; ++i) {
Opt->keys[i] = i+1;
}
}
}
/* Make sure you have no negative values and requesting bias field correction.
The implementation uses log() for this so the negative values would be
ill advised */
{
float amin, amax;
THD_subbrick_minmax(Opt->aset, 0, 1,&amin, &amax);
if (amin < 0 && Opt->bias_param > 0) {
SUMA_S_Err("Cannot use field bias correction on volumes with negative\n"
"values. Either turn off bias field estimation with -bias_fwhm 0.0\n"
"or shift the values of the input by something like:\n"
" 3dcalc -a %s -expr 'a+bool(a)*%d' -prefix SHIFTED\n"
"and rerun the segmentation on SHIFTED. Note the suggested shift\n"
"leaves zero values unchanged.",
DSET_HEADNAME(Opt->aset), (int)ceil(-amin+1.0));
exit(1);
}
}
/* Show the match between keys and classes */
if (Opt->debug > 1) {
SUMA_S_Note("Class-->key map");
SUMA_ShowClssKeys(Opt->clss->str, Opt->clss->num, Opt->keys);
}
if (Opt->clss->num < 2) {
if (Opt->debug <= 1) {
SUMA_S_Note("Class-->key map");
SUMA_ShowClssKeys(Opt->clss->str, Opt->clss->num, Opt->keys);
}
SUMA_S_Err("Less than 2 classes? I am out of here");
SUMA_RETURN(0);
}
/* Mask setup */
if (Opt->debug > 1) {
SUMA_S_Note("MaskSetup");
}
Opt->cmask = MaskSetup(Opt, Opt->aset, 1,
&(Opt->mset), &(Opt->cmask), Opt->dimcmask,
Opt->mask_bot, Opt->mask_top, &(Opt->cmask_count));
if (Opt->VoxDbg >= 0) {
SUMA_S_Note("DBG setup");
fprintf(Opt->VoxDbgOut, "Command:");
for (i=0; i<argc; ++i) {
fprintf(Opt->VoxDbgOut, "%s ", argv[i]);
}
fprintf(Opt->VoxDbgOut, "\nDebug info for voxel %d\n", Opt->VoxDbg);
}
Opt->cs = SUMA_New_Class_Stat(Opt->clss->str, Opt->clss->num,
Opt->keys, 3, NULL);
/* Load prob. of class given features */
if (Opt->priCgAname && strcmp(Opt->priCgAname, "INIT_MIXFRAC")) {
if (!(Opt->priCgA = Seg_load_dset(Opt->priCgAname))) {
SUMA_S_Errv("Failed to read priCgA %s\n", Opt->priCgAname);
SUMA_RETURN(1);
}
if (GRID_MISMATCH(Opt->priCgA, Opt->aset)) {
SUMA_S_Err("All input data must have same grid (-priCgA != -aset)");
SUMA_RETURN(1);
}
/* Make sure dset is properly formatted */
if (!SUMA_ShortizeProbDset(&Opt->priCgA,
Opt->cs,
Opt->cmask, Opt->cmask_count,
Opt, &Opt->priCgA)) {
SUMA_S_Errv("Failed to shortize priCgA %s\n", Opt->priCgAname);
SUMA_RETURN(1);
}
/* set the floor of the input dset */
if (0) {
SUMA_S_Note("Setting probability floor, USEFULNESS NOT TESTED...");
if (!set_p_floor(Opt->priCgA, 0.1, Opt->cmask)) {
SUMA_S_Errv("Failed to set p floor for priCgA %s\n",
Opt->priCgAname);
SUMA_RETURN(1);
}
}
} else {
/* uniform probability */
}
/* Load prob. of class given location */
if (Opt->priCgLname && strcmp(Opt->priCgLname, "INIT_MIXFRAC")) {
if (!(Opt->priCgL = Seg_load_dset(Opt->priCgLname))) {
SUMA_S_Errv("Failed to read priCgL %s\n", Opt->priCgLname);
SUMA_RETURN(1);
}
if (GRID_MISMATCH(Opt->priCgL, Opt->aset)) {
SUMA_S_Err("All input data must have same grid (-priCgL != -aset)");
SUMA_RETURN(1);
}
/* Make sure dset is properly formatted */
if (!SUMA_ShortizeProbDset(&Opt->priCgL,
Opt->cs,
Opt->cmask, Opt->cmask_count,
Opt, &Opt->priCgL)) {
SUMA_S_Errv("Failed to shortize priCgL %s\n", Opt->priCgLname);
SUMA_RETURN(1);
}
} else {
/* uniform probability */
}
/* check on weights of priors */
if (Opt->wA >= 0.0 && Opt->wL < 0.0) {
Opt->wL = 1.0 - Opt->wA;
} else if (Opt->wL >= 0.0 && Opt->wA < 0.0) {
Opt->wA = 1.0 - Opt->wL;
} else if (Opt->wA < 0.0 && Opt->wL < 0.0) { /* defaults */
Opt->wA = 0.5; Opt->wL = 0.5;
}
ff = Opt->wA+Opt->wL;
Opt->wA = Opt->wA/ff; Opt->wL = Opt->wL/ff;
if (!Opt->cset) {
if (!SUMA_SegInitCset(Opt->aset,
&Opt->cset,
Opt->cmask, Opt->cmask_count,
Opt->mixopt,
Opt->cs,
Opt)) {
SUMA_S_Err("Failed to get initializer");
SUMA_RETURN(1);
}
}
if (Opt->debug > 1) {
SUMA_Seg_Write_Dset(Opt->proot, "classes_init", Opt->cset,
-1, Opt->hist);
}
/* Now add the 'OTHER' class if needed */
if (Opt->Other) {
if (!SUMA_AddOther( Opt->clss, &Opt->keys,
Opt->cmask, Opt->cmask_count,
Opt->cset, Opt->pstCgALL,
Opt->priCgA, Opt->priCgL,
Opt->cs)) {
SUMA_S_Err("Failed to add other");
SUMA_RETURN(0);
}
}
/* store mixfrac in class stats */
for (i=0;i<Opt->cs->N_label; ++i) {
if ((ff = SUMA_mixopt_2_mixfrac(Opt->mixopt, Opt->cs->label[i],
Opt->cs->keys[i], Opt->cs->N_label,
Opt->cmask, Opt->cset))<0.0) {
SUMA_S_Errv("Can't get mixfrac for %s\n", Opt->mixopt);
SUMA_RETURN(1);
}
SUMA_set_Stat(Opt->cs, Opt->cs->label[i], "init.mix", ff);
SUMA_set_Stat(Opt->cs, Opt->cs->label[i], "mix", ff);
}
/* Now call the workhorse */
if (!SUMA_SegEngine(Opt)) {
SUMA_S_Err("Failed in SUMA_SegEngine");
exit(1);
}
/* write output */
if (Opt->Bset && !Opt->this_fset_name) {
tross_Append_History(Opt->Bset, Opt->hist);
SUMA_Seg_Write_Dset(Opt->proot, "BiasField", /* DSET_PREFIX(Opt->Bset) */
Opt->Bset, -1, Opt->hist);
}
if (Opt->xset && !Opt->this_xset_name) {
AFNI_FEED(Opt->ps->cs, "BiasCorrect", -1, Opt->xset);
SUMA_Seg_Write_Dset(Opt->proot, "AnatUB", /* DSET_PREFIX(Opt->xset)*/
Opt->xset, -1, Opt->hist);
}
if (Opt->cset) {
SUMA_Seg_Write_Dset(Opt->proot, "Classes", /* Opt->crefix */
Opt->cset, -1, Opt->hist);
AFNI_FEED(Opt->ps->cs, "FinalClasses", -1, Opt->cset);
}
if (Opt->pstCgALL) {
SUMA_Seg_Write_Dset(Opt->proot, "Posterior", /* Opt->prefix */
Opt->pstCgALL, -1, Opt->hist);
AFNI_FEED(Opt->ps->cs, "pstCgALL-final", -1, Opt->pstCgALL);
}
if (Opt->aset) {
SUMA_Seg_Write_Dset(Opt->proot, "Anat",
Opt->aset, -1, Opt->hist);
}
if (Opt->debug) SUMA_S_Note("Writing Unmodulated output");
if (!(SUMA_pst_C_giv_ALL(Opt->xset,
Opt->cmask, Opt->cmask_count,
Opt->cs,
NULL, NULL,
Opt->B, Opt->T, 0,
&Opt->pstCgALL))) {
SUMA_S_Err("Failed in SUMA_pst_C_giv_ALL unmodulated");
SUMA_RETURN(1);
}
SUMA_Seg_Write_Dset(Opt->proot, "Unmodulated.p",
Opt->pstCgALL, -1, Opt->hist);
if (!(SUMA_assign_classes( Opt->pstCgALL, Opt->cs,
Opt->cmask, &Opt->cset))) {
SUMA_S_Err("Failed in assign_classes");
SUMA_RETURN(1);
}
SUMA_Seg_Write_Dset(Opt->proot, "Unmodulated.c",
Opt->cset, -1, Opt->hist);
/* all done, free */
Opt = free_SegOpts(Opt);
PRINT_COMPILE_DATE ;
SUMA_RETURN(0);
}
/*!
\brief parse the arguments for SurfSmooth program
\param argv (char *)
\param argc (int)
\return Opt (SUMA_GETPATCH_OPTIONS *) options structure.
To free it, use
SUMA_free(Opt->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);
}
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[]={"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[]={"FSread_annot"};
int kar, Showct, testmode;
char *fname = NULL, *fcmap = NULL, *fdset = NULL,
*froi = NULL, *fcol = NULL, *ctfile=NULL, sbuf[1024]={""};
SUMA_Boolean SkipCoords = NOPE, brk;
SUMA_DSET *dset=NULL;
int lbl1,lbl2, ver, hemi, FSdefault;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
/* allocate space for CommonFields structure */
SUMAg_CF = SUMA_Create_CommonFields ();
if (SUMAg_CF == NULL) {
fprintf( SUMA_STDERR,
"Error %s: Failed in SUMA_Create_CommonFields\n", FuncName);
exit(1);
}
/* parse command line */
kar = 1;
fname = NULL;
froi = NULL;
fcmap = NULL;
fcol = NULL;
brk = NOPE;
ctfile = NULL;
Showct = 0;
testmode = 0;
lbl1 = -1;
lbl2 = -1;
ver = -1;
FSdefault = 0;
hemi=0;
while (kar < argc) { /* loop accross command ine options */
/*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/
if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) {
usage_SUMA_FSread_annot_Main();
exit (0);
}
if (!brk && (strcmp(argv[kar], "-show_FScmap") == 0)) {
Showct = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-testmode") == 0)) {
testmode = 1;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-input") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -input\n");
exit (1);
}
fname = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-FScmap") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -FScmap\n");
exit (1);
}
ctfile = argv[kar];
if (!strcmp(ctfile,"FS_DEFAULT")) {
char *eee = getenv("FREESURFER_HOME");
if (!eee) {
SUMA_S_Err("Environment variable FREESURFER_HOME not set.\n"
"Cannot locate FreeSurferColorLUT.txt\n");
exit (1);
} else {
sprintf(sbuf, "%s/FreeSurferColorLUT.txt", eee);
ctfile = sbuf;
FSdefault = 1;
SUMA_S_Notev("Using %s\n", ctfile);
}
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-FSversion") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -FSversion\n");
exit (1);
}
if (strstr(argv[kar],"2009")) ver = 2009;
else if (strstr(argv[kar],"2005")) ver = 2005;
else {
fprintf (SUMA_STDERR,
"Bad value for -FSversion of %s (looking for 2005 or 2009)\n",
argv[kar]);
exit (1);
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-hemi") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -hemi\n");
exit (1);
}
if (strstr(argv[kar],"lh")) hemi = -1;
else if (strstr(argv[kar],"rh")) hemi = 1;
else {
fprintf (SUMA_STDERR,
"Bad value for -hemi of %s (looking for lh or rh)\n",
argv[kar]);
exit (1);
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-FScmaprange") == 0)) {
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need 2 argument after -FScmaprange\n");
exit (1);
}
lbl1 = atoi(argv[kar]); ++kar;
lbl2 = atoi(argv[kar]);
if (lbl1 > lbl2 || lbl1 < -1) {
fprintf (SUMA_STDERR,
"Bad value for -FScmaprange of [%d %d]\n",
lbl1, lbl2);
exit (1);
}
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-roi_1D") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -ROI_1D\n");
exit (1);
}
froi = argv[kar];
brk = YUP;
}
if (!brk && ( (strcmp(argv[kar], "-prefix") == 0) ||
(strcmp(argv[kar], "-dset") == 0) ) ) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -dset\n");
exit (1);
}
fdset = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-cmap_1D") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -cmap_1D\n");
exit (1);
}
fcmap = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-col_1D") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -col_1D\n");
exit (1);
}
fcol = argv[kar];
brk = YUP;
}
if (!brk) {
fprintf (SUMA_STDERR,
"Error %s:\n"
"Option %s not understood. Try -help for usage\n",
FuncName, argv[kar]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}
if (!fname) {
SUMA_SL_Err("No input file specified.");
exit(1);
}
if (ver == -1) {
/* guess at version */
if (strstr(fname,"2009")) {
ver = 2009;
SUMA_S_Notev("Guessed FS annot version of %d\n", ver);
} else if (strstr(fname,"2005")) {
ver = 2005;
SUMA_S_Notev("Guessed FS annot version of %d\n", ver);
} else {
SUMA_S_Notev("Assuming FS annot version of %d\n", ver);
}
}
if (hemi == 0) {
if (strstr(fname,"lh.")) {
hemi = -1;
SUMA_S_Note("Guessed left hemisphere");
} else if (strstr(fname,"rh.")) {
SUMA_S_Note("Guessed right hemisphere");
hemi = 1;
} else {
if (ver == 2009) {
hemi = -1;
SUMA_S_Note("Assuming left hemisphere.\n");
} else {
/* leave it not set */
}
}
}
if (ver == 2009 && !ctfile) {
char *eee = getenv("FREESURFER_HOME");
if (!eee) {
SUMA_S_Warn("Environment variable FREESURFER_HOME not set.\n"
"Cannot locate FreeSurferColorLUT.txt\n");
} else {
sprintf(sbuf, "%s/FreeSurferColorLUT.txt", eee);
ctfile = sbuf;
SUMA_S_Notev("Using %s\n", ctfile);
}
}
if (lbl1 < 0 && lbl2 < 0) {
/* need some setup */
if (ver == 2009) {
if (hemi == -1) {
lbl1 = 13100;
lbl2 = 13199;
SUMA_S_Notev("Setting -FScmaprange to [%d %d]\n",
lbl1, lbl2);
} else if (hemi == 1) {
lbl1 = 14100;
lbl2 = 14199;
SUMA_S_Notev("Setting -FScmaprange to [%d %d]\n",
lbl1, lbl2);
} else {
SUMA_S_Warn("-FScmaprange is not set.\n"
"You may need to set it, check results.\n");
}
} else if (ver == 2005 && FSdefault) {
if (hemi == -1) {
lbl1 = 3100;
lbl2 = 3199;
SUMA_S_Notev("Setting -FScmaprange to [%d %d]\n",
lbl1, lbl2);
} else if (hemi == 1) {
lbl1 = 4100;
lbl2 = 4199;
SUMA_S_Notev("Setting -FScmaprange to [%d %d]\n",
lbl1, lbl2);
} else {
SUMA_S_Warn("-FScmaprange is not set.\n"
"You may need to set it, check results.\n");
}
}
}
if (!fcmap && !froi && !fcol && !Showct && !fdset) {
SUMA_SL_Err("Nothing to do.\n"
"Use either -cmap_1D or \n"
" -roi_1D or -col_1D or \n"
" -show_FScmap options.");
exit(1);
}
if (fdset) {
int exists = 0;
char *ooo=NULL;
exists = SUMA_WriteDset_NameCheck_s (fdset, NULL,
SUMA_ASCII_NIML, 0, &ooo);
if (exists != 0 && !THD_ok_overwrite()) {
SUMA_S_Errv("Output dataset %s exists.\n", ooo);
SUMA_free(ooo); ooo=NULL;
exit(1);
}
}
if (froi) {
if (SUMA_filexists(froi) && !THD_ok_overwrite()) {
fprintf( SUMA_STDERR,
"Error %s: File %s exists, will not overwrite.\n",
FuncName, froi);
SUMA_RETURN (NOPE);
}
}
if (fcmap) {
if (SUMA_filexists(fcmap) && !THD_ok_overwrite()) {
fprintf( SUMA_STDERR,
"Error %s: File %s exists, will not overwrite.\n",
FuncName, fcmap);
SUMA_RETURN (NOPE);
}
}
if (fcol) {
if (SUMA_filexists(fcol) && !THD_ok_overwrite()) {
fprintf( SUMA_STDERR,
"Error %s: File %s exists, will not overwrite.\n",
FuncName, fcol);
SUMA_RETURN (NOPE);
}
}
if (!SUMA_readFSannot (fname, froi, fcmap, fcol, Showct, ctfile,
lbl1, lbl2, &dset)) {
SUMA_S_Err("Failed reading annotation file (or output file exists)");
exit(1);
}
if (!dset && fdset) {
SUMA_S_Err("Have no dset to write");
exit(1);
}
if (fdset) {
if (AFNI_yesenv("AFNI_NIML_TEXT_DATA")) {
SUMA_WriteDset_eng(fdset, dset, SUMA_ASCII_NIML, 1, 1, 1);
} else {
SUMA_WriteDset_eng(fdset, dset, SUMA_BINARY_NIML, 1, 1, 1);
}
}
if (testmode) {
int key, indx, ism, suc;
SUMA_COLOR_MAP *SM2=NULL, *SM=NULL;
char *s=NULL, stmp[256];
SUMA_PARSED_NAME *sname=NULL;
NI_group *ngr=NULL;
SUMA_S_Note("Testing Chunk Begins");
/* check */
if (!SUMA_is_Label_dset(dset, &ngr)) {
SUMA_S_Err("Dset is no label dset");
exit(1);
}
/* write it */
/* play with the colormap */
if (ngr) {
if (!(SM = SUMA_NICmapToCmap(ngr))){
SUMA_S_Err("Failed to create SUMA colormap");
exit(1);
}
ngr = NULL; /* that's a copy of what was in dset, do not free it */
if (!SUMA_CreateCmapHash(SM)) {
SUMA_S_Err("Failed to create hash");
exit(1);
}
/* Now pretend you are retrieving the index in cmap of some key */
for (ism=0; ism < SM->N_M[0]; ++ism) {
/* the key is coming from SM, because I store all keys there
But key normally comes from a certain node's value */
key = SM->idvec[ism];
indx = SUMA_ColMapKeyIndex(key, SM);
if (indx < 0) {
SUMA_S_Errv("Hashkey %d not found\n", key);
} else {
fprintf(SUMA_STDERR,
"hashed id %d --> index %d\n"
"known id %d --> index %d\n",
key, indx,
key, ism);
}
}
/* Now try it with an unknown key */
key = -13;
indx = SUMA_ColMapKeyIndex(key, SM);
if (indx < 0) {
fprintf(SUMA_STDERR,
"id %d is not in the hash table, as expected\n", key);
} else {
SUMA_S_Errv("Should not have found %d\n", key);
}
SUMA_S_Note("Now Show it to me");
s = SUMA_ColorMapVec_Info (&SM, 1, 2);
if (s) {
fprintf(SUMA_STDERR,"%s", s); SUMA_free(s); s = NULL;
}
SUMA_S_Notev("Now turn it to niml (%s)\n", SM->Name);
ngr = SUMA_CmapToNICmap(SM);
sname = SUMA_ParseFname(SM->Name, NULL);
snprintf(stmp, 128*sizeof(char),
"file:%s.niml.cmap", sname->FileName_NoExt);
NEL_WRITE_TX(ngr, stmp, suc);
if (!suc) {
SUMA_S_Errv("Failed to write %s\n", stmp);
}
SUMA_Free_Parsed_Name(sname); sname = NULL;
SUMA_S_Note("Now turn niml colormap to SUMA's colormap");
SM2 = SUMA_NICmapToCmap(ngr);
SUMA_S_Note("Now Show it to me2");
s = SUMA_ColorMapVec_Info (&SM2, 1, 2);
if (s) {
fprintf(SUMA_STDERR,"%s", s); SUMA_free(s); s = NULL;
}
NI_free_element(ngr); ngr=NULL;
SUMA_Free_ColorMap(SM); SM = NULL;
SUMA_Free_ColorMap(SM2); SM2 = NULL;
}
SUMA_S_Note("Testing Chunk End");
}
if (dset) SUMA_FreeDset(dset); dset = NULL;
exit(0);
}
int GenFeatureDist_CheckOpts(SEG_OPTS *Opt)
{
static char FuncName[]={"GenFeatureDist_CheckOpts"};
int i=0, kk=0, nmatch;
SUMA_ENTRY;
if (!Opt->clss) {
SUMA_S_Err("Need -classes option");
SUMA_RETURN(1);
}
if (!Opt->sig_names) {
SUMA_S_Err("Need -sig option");
SUMA_RETURN(1);
}
if (!Opt->samp_names) {
SUMA_S_Err("Need -samp option");
SUMA_RETURN(1);
}
if (Opt->samp_names->num != Opt->sig_names->num) {
SUMA_S_Errv("Need as many -samp options (%d) as -sig options (%d)\n",
Opt->samp_names->num, Opt->sig_names->num);
SUMA_RETURN(1);
}
/* labeltable? */
if (Opt->labeltable_name) {
Dtable *vl_dtable=NULL;
char *labeltable_str=NULL;
/* read the table */
if (!(labeltable_str = AFNI_suck_file( Opt->labeltable_name))) {
ERROR_exit("Failed to read %s", Opt->labeltable_name);
}
if (!(vl_dtable = Dtable_from_nimlstring(labeltable_str))) {
ERROR_exit("Could not parse labeltable");
}
/* make sure all classes are in the labeltable */
for (i=0; i<Opt->clss->num; ++i) {
if ((kk = SUMA_KeyofLabel_Dtable(vl_dtable, Opt->clss->str[i]))<0){
ERROR_exit("Key not found in %s for %s ",
Opt->labeltable_name, Opt->clss->str[i]);
}
if (Opt->keys) {
if (Opt->keys[i]!=kk) {
ERROR_exit("Key mismatch %d %d", Opt->keys[i], kk);
}
}
}
if (!Opt->keys) { /* get them from table */
Opt->keys = (int *)calloc(Opt->clss->num, sizeof(int));
for (i=0; i<Opt->clss->num; ++i) {
if ((kk = SUMA_KeyofLabel_Dtable(vl_dtable, Opt->clss->str[i]))<0){
ERROR_exit("(should noy happen) Key not found in %s for %s ",
Opt->labeltable_name, Opt->clss->str[i]);
}
Opt->keys[i] = kk;
}
}
destroy_Dtable(vl_dtable); vl_dtable=NULL;
}
/* Make sure any histogram specs are for a class in use */
for (kk=0; kk<Opt->N_hspec; ++kk) {
if ( (nmatch = SUMA_is_wild_hspec_label(Opt->hspec[kk]->label)) >= 0) {
if (!nmatch) break;
for (i=0; i<Opt->feats->num; ++i) {
if (!strncmp(Opt->feats->str[i],
Opt->hspec[kk]->label, nmatch)) break;
}
} else {
for (i=0; i<Opt->feats->num; ++i) {
if (!strcmp(Opt->feats->str[i], Opt->hspec[kk]->label)) break;
}
}
if (i==Opt->feats->num) {
SUMA_S_Warn("Feature %s in -hspec not found under -features and will have no impact on the output\n",
Opt->hspec[kk]->label);
}
}
if (!Opt->keys) {
/* add default keys */
if (Opt->debug) SUMA_S_Note("Keys not available, assuming defaults");
Opt->keys = (int *)calloc(Opt->clss->num, sizeof(int));
for (i=0; i<Opt->clss->num; ++i) {
Opt->keys[i] = i+1;
}
}
/* Show the match between keys and classes */
if (Opt->debug > 1) {
SUMA_S_Note("Class-->key map");
SUMA_ShowClssKeys(Opt->clss->str, Opt->clss->num, Opt->keys);
}
if( ! THD_is_directory(Opt->proot) ){
if( mkdir( Opt->proot , THD_MKDIR_MODE ) != 0 ){
SUMA_S_Errv("Failed to create %s\n", Opt->proot);
SUMA_RETURN(0);
}
}
SUMA_RETURN(1);
}
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);
}
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[]={"ScaleToMap"};
char *IntName = NULL, *Prfx, h[9],
*CmapFileName = NULL, *dbfile = NULL, *MapName=NULL;
MRI_IMAGE *im = NULL;
float *far=NULL;
int N_V, N_Int, kar, k, ii, i, icol=-1, vcol=-1, Sgn, interpmode, k3;
int Vminloc, Vmaxloc, *iV = NULL;
float Vmin, Vmax, brfact;
float *V = NULL, *Vsort = NULL;
float IntRange[2], MaskColor[3], MaskRange[2]={0.0, 0.0}, arange;
SUMA_Boolean ApplyClip, ApplyMask, setMaskCol, ApplyPercClip, Vopt;
SUMA_Boolean iVopt, inopt, NoMaskCol, MapSpecified, alaAFNI, MaskZero;
SUMA_Boolean brk, frf, ShowMap, ShowMapdb;
SUMA_COLOR_MAP *CM;
SUMA_SCALE_TO_MAP_OPT * OptScl;
int MapType, freecm = 1;
SUMA_COLOR_SCALED_VECT * SV;
SUMA_AFNI_COLORS *SAC=NULL;
SUMA_Boolean FromAFNI = NOPE;
int imap, isPmap, isNmap;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMAg_CF->isGraphical = YUP;
SUMA_mainENTRY;
/* this is placed down here to */
/*
if (argc < 3) {
SUMA_ScaleToMap_usage();
exit (1);
}
*/
kar = 1;
brfact = 1; /* the brightness factor */
MaskColor[0] = MaskColor[1] = MaskColor[2] = 0.3;
ApplyClip = NOPE;
ApplyPercClip = NOPE;
ApplyMask = NOPE;
NoMaskCol = NOPE;
MaskZero = NOPE;
setMaskCol = NOPE;
Vopt = NOPE;
iVopt = NOPE;
inopt = NOPE;
MapType = SUMA_CMAP_RGYBR20;
brk = NOPE;
MapSpecified = NOPE;
CmapFileName = NULL;
interpmode = SUMA_UNDEFINED_MODE;
ShowMap = NOPE;
alaAFNI = NOPE; /* applying the alaAFNI mapping */
frf = NOPE;
arange = -1.0; /* afni range specified */
Sgn = 0;
ShowMapdb = NOPE;
while (kar < argc) { /* loop accross command ine options */
/*fprintf(stdout, "%s verbose: Parsing command line...\n", FuncName);*/
if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) {
SUMA_ScaleToMap_usage();
exit (1);
}
SUMA_SKIP_COMMON_OPTIONS(brk, kar);
if (!brk && strcmp(argv[kar], "-verb") == 0) {
LocalHead = NOPE;
brk = YUP;
}
if (!brk && strcmp(argv[kar], "-ionot") == 0) {
SUMA_SL_Err("-ionot is obsolete. \n"
"Use -trace option.");
exit (1);
SUMA_INOUT_NOTIFY_ON;
brk = YUP;
}
if (!brk && strcmp(argv[kar], "-msk_zero") == 0) {
MaskZero = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-input") == 0)) {
kar ++;
if (kar+2 >= argc) {
fprintf (SUMA_STDERR, "need 3 arguments after -input \n");
exit (1);
}
IntName = argv[kar]; kar ++;
icol = atoi(argv[kar]); kar ++;
vcol = atoi(argv[kar]);
inopt = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-apr") == 0)) {
if (arange >= 0) {
fprintf (SUMA_STDERR, "range has already been specified.\n");
exit (1);
}
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -apr \n");
exit (1);
}
arange = atof(argv[kar]);
if (arange < 0) {
fprintf (SUMA_STDERR, "range must be positive.\n");
exit (1);
}
Sgn = 1;
alaAFNI = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-anr") == 0)) {
if (arange >= 0) {
fprintf (SUMA_STDERR, "range has already been specified.\n");
exit (1);
}
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -anr \n");
exit (1);
}
arange = atof(argv[kar]);
if (arange < 0) {
fprintf (SUMA_STDERR, "range must be positive.\n");
exit (1);
}
Sgn = -1;
alaAFNI = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-v") == 0)) {
fprintf (SUMA_STDERR, "\n -v option is now obsolete.\nUse -input option instead.\n");
exit (1);
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -v \n");
exit (1);
}
IntName = argv[kar];
Vopt = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-iv") == 0)) {
fprintf (SUMA_STDERR, "\n -iv option is now obsolete.\nUse -input option instead.\n");
exit (1);
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -iv \n");
exit (1);
}
IntName = argv[kar];
iVopt = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-br") == 0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need argument after -br \n");
exit (1);
}
brfact = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-frf") == 0)) {
frf = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-showmap") == 0)) {
ShowMap = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-showdb") == 0)) {
ShowMapdb = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-nointerp") == 0)) {
if (interpmode != SUMA_UNDEFINED_MODE) {
fprintf (SUMA_STDERR, "Color interpolation mode already set.\n");
}
interpmode = SUMA_NO_INTERP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-direct") == 0)) {
if (interpmode != SUMA_UNDEFINED_MODE) {
fprintf (SUMA_STDERR, "Color interpolation mode already set.\n");
}
interpmode = SUMA_DIRECT;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-interp") == 0)) {
if (interpmode != SUMA_UNDEFINED_MODE) {
fprintf (SUMA_STDERR, "Color interpolation mode already set.\n(-nointerp, -direct and -interp are mutually exclusive.\n");
}
interpmode = SUMA_INTERP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-clp") == 0)) {
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need 2 arguments after -clp \n");
exit (1);
}
ApplyClip = YUP;
IntRange[0] = atof(argv[kar]); kar ++;
IntRange[1] = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-perc_clp") == 0)) {
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need 2 arguments after -perc_clp ");
exit (1);
}
ApplyPercClip = YUP;
IntRange[0] = atof(argv[kar]); kar ++;
IntRange[1] = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-msk") == 0)) {
kar ++;
if (kar+1 >= argc) {
fprintf (SUMA_STDERR, "need 2 arguments after -msk ");
exit (1);
}
ApplyMask = YUP;
MaskRange[0] = atof(argv[kar]); kar ++;
MaskRange[1] = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-nomsk_col") == 0)) {
NoMaskCol = YUP;
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-msk_col") == 0)) {
kar ++;
if (kar+2 >= argc) {
fprintf (SUMA_STDERR, "need 3 arguments after -msk_col ");
exit (1);
}
setMaskCol = YUP;
MaskColor[0] = atof(argv[kar]); kar ++;
MaskColor[1] = atof(argv[kar]); kar ++;
MaskColor[2] = atof(argv[kar]);
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-cmapfile") ==0)) {
if (MapSpecified) {
fprintf (SUMA_STDERR, "Color map already specified.\n-cmap and -cmapfile are mutually exclusive\n");
exit (1);
}
MapSpecified = YUP;
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need 1 arguments after -cmapfile ");
exit (1);
}
CmapFileName = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-cmapdb") ==0)) {
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need 1 arguments after -cmapdb ");
exit (1);
}
dbfile = argv[kar];
brk = YUP;
}
if (!brk && (strcmp(argv[kar], "-cmap") ==0)) {
if (MapSpecified) {
fprintf (SUMA_STDERR, "Color map already specified.\n-cmap and -cmapfile are mutually exclusive\n");
exit (1);
}
MapSpecified = YUP;
kar ++;
if (kar >= argc) {
fprintf (SUMA_STDERR, "need 1 arguments after -cmap ");
exit (1);
}
MapName = argv[kar];
brk = YUP;
}
if (!brk) {
fprintf (SUMA_STDERR,"Error %s: Option %s not understood. Try -help for usage\n", FuncName, argv[kar]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}/* loop accross command ine options */
/* Get your colors straightened out */
if (!SUMAg_CF->scm) {
SUMAg_CF->scm = SUMA_Build_Color_maps();
if (!SUMAg_CF->scm) {
SUMA_SL_Err("Failed to build color maps.\n");
exit(1);
}
}
SAC = SUMAg_CF->scm;
/* are there database files to read */
if (dbfile) {
SUMA_LH("Now trying to read db file");
if (SUMA_AFNI_Extract_Colors ( dbfile, SAC ) < 0) {
SUMA_S_Errv("Failed to read %s colormap file.\n", dbfile);
exit(1);
}
}
FromAFNI = NOPE; /* assume colormap is not coming from SAC
(the colormap database structure) */
if (CmapFileName) {
/* load the color map */
CM = SUMA_Read_Color_Map_1D (CmapFileName);
if (CM == NULL) {
SUMA_S_Err("Could not load colormap.\n");
exit (1);
}
if (frf) {
SUMA_LH("Flipping colormap");
SUMA_Flip_Color_Map (CM);
}
if (!CM->Sgn) CM->Sgn = Sgn;
}else{
/* dunno what kind of map yet. Try default first */
if (MapName) {
CM = SUMA_FindNamedColMap (MapName);
freecm = 0;
if (CM) {
/* good, sign it and out you go */
CM->Sgn = Sgn;
} else {
SUMA_S_Err("Could not get standard colormap.\n");
exit (1);
}
} else {
SUMA_LH("An AFNI color map ");
/* a color from AFNI's maps */
FromAFNI = YUP;
imap = SUMA_Find_ColorMap ( MapName, SAC->CMv, SAC->N_maps, -2);
if (imap < 0) {
SUMA_S_Errv("Could not find colormap %s.\n", MapName);
exit (1);
}
CM = SAC->CMv[imap];
}
}
/* show the colromap on STDERR */
if (ShowMap) {
fprintf (SUMA_STDERR, "%s: Colormap used:\n", FuncName);
SUMA_Show_ColorMapVec (&CM, 1, NULL, 2);
{
SUMA_SurfaceObject *SO = NULL;
float orig[3] = { SUMA_CMAP_ORIGIN };
float topright[3] = { SUMA_CMAP_TOPLEFT };
SO = SUMA_Cmap_To_SO (CM, orig, topright, 2);
if (SO) SUMA_Free_Surface_Object(SO);
}
exit(0);
}
/* show all the colors and colormaps in SAC on STDERR */
if (ShowMapdb) {
fprintf (SUMA_STDERR, "%s: AFNI colormaps found in db:\n", FuncName);
SUMA_Show_ColorVec (SAC->Cv, SAC->N_cols, NULL);
SUMA_Show_ColorMapVec (SAC->CMv, SAC->N_maps, NULL, 2);
exit(0);
}
if (!IntName) {
fprintf (SUMA_STDERR,"Error %s: No input file specified.\n", FuncName);
exit(1);
}
/* default interpolation mode */
if (interpmode == SUMA_UNDEFINED_MODE) interpmode = SUMA_INTERP;
/* check input */
if (!SUMA_filexists (IntName)) {
fprintf (SUMA_STDERR,"Error %s: File %s could not be found.\n", FuncName, IntName);
exit(1);
}
if (frf && !CmapFileName) {
fprintf (SUMA_STDERR,"Error %s: -frf option is only valid with -cmapfile.\n", FuncName);
exit(1);
}
if (ApplyPercClip && ApplyClip) {
fprintf (SUMA_STDERR,"Error %s: Simultaneous use of -clp and -perc_clp. You should be punished.\n", FuncName);
exit(1);
}
if ((ApplyPercClip || ApplyClip) && arange >= 0.0) {
fprintf (SUMA_STDERR,"Error %s: Simultaneous use of -clp/-perc_clp and -apr/anr.\n Read the help.\n", FuncName);
exit(1);
}
if (iVopt || Vopt) {
fprintf (SUMA_STDERR,"Error %s: -v and -iv are obsolete.\n Use -input option instead.\n", FuncName);
exit(1);
}
if (!inopt) {
fprintf (SUMA_STDERR,"Error %s: -input option must be specified.\n", FuncName);
exit(1);
}
im = mri_read_1D (IntName);
if (!im) {
SUMA_S_Err("Failed to read file");
exit (1);
}
if (vcol < 0) {
fprintf (SUMA_STDERR,"Error %s: vcol must be > 0\n", FuncName);
exit(1);
}
far = MRI_FLOAT_PTR(im);
if (icol < 0 && icol != -1) {
fprintf (SUMA_STDERR,"Error %s: icol(%d) can only have -1 for a negative value\n", FuncName, icol);
exit(1);
}
if (icol >= im->ny || vcol >= im->ny) {
fprintf (SUMA_STDERR,"Error %s: icol(%d) and vcol(%d) must be < %d\nwhich is the number of columns in %s\n",
FuncName, icol, vcol, im->ny, IntName);
exit(1);
}
if (brfact <=0 || brfact > 1) {
fprintf (SUMA_STDERR,"Error %s: BrightFact must be > 0 and <= 1.\n", FuncName);
exit (1);
}
if (MaskColor[0] < 0 || MaskColor[0] > 1 || MaskColor[1] < 0 || MaskColor[1] > 1 || MaskColor[2] < 0 || MaskColor[2] > 1) {
fprintf (SUMA_STDERR,"Error %s: MaskColor values must be >=0 <=1.\n", FuncName);
exit(1);
}
N_V = im->nx;
V = (float *) SUMA_calloc (N_V, sizeof(float));
iV = (int *) SUMA_calloc (N_V, sizeof(int));
if (!V || !iV) {
fprintf (SUMA_STDERR,"Error %s: Could not allocate for V or iV.\n", FuncName);
exit(1);
}
if (icol < 0) {
for (ii=0; ii < N_V; ++ii) {
iV[ii] = ii;
V[ii] = far[vcol*N_V+ii];
}
} else {
for (ii=0; ii < N_V; ++ii) {
iV[ii] = (int)far[icol*N_V+ii];
V[ii] = far[vcol*N_V+ii];
}
}
mri_free(im); im = NULL;
/* read values per node */
/* SUMA_disp_vect (V, 3); */
/* find the min/max of V */
SUMA_MIN_MAX_VEC(V, N_V, Vmin, Vmax, Vminloc, Vmaxloc)
/* fprintf (SUMA_STDERR,"%s: Vmin=%f, Vmax = %f\n", FuncName, Vmin, Vmax);*/
if (arange == 0.0) {
if (fabs((double)Vmin) > fabs((double)Vmax)) arange = (float)fabs((double)Vmin);
else arange = (float)fabs((double)Vmax);
}
/* figure out the range if PercRange is used */
if (ApplyPercClip) {
fprintf (SUMA_STDERR,"%s: Percentile range [%f..%f] is equivalent to ", FuncName, IntRange[0], IntRange[1]);
Vsort = SUMA_PercRange (V, NULL, N_V, IntRange, IntRange, NULL);
fprintf (SUMA_STDERR,"[%f..%f]\n", IntRange[0], IntRange[1]);
ApplyClip = YUP;
if (Vsort) SUMA_free(Vsort);
else {
fprintf (SUMA_STDERR,"Error %s: Error in SUMA_PercRange.\n", FuncName);
exit(1);
}
}
/* get the options for creating the scaled color mapping */
OptScl = SUMA_ScaleToMapOptInit();
if (!OptScl) {
fprintf (SUMA_STDERR,
"Error %s: Could not get scaling option structure.\n", FuncName);
exit (1);
}
/* work the options a bit */
if (ApplyMask) {
OptScl->ApplyMask = ApplyMask;
OptScl->MaskRange[0] = MaskRange[0];
OptScl->MaskRange[1] = MaskRange[1];
OptScl->MaskColor[0] = MaskColor[0];
OptScl->MaskColor[1] = MaskColor[1];
OptScl->MaskColor[2] = MaskColor[2];
}
if (ApplyClip) {
OptScl->ApplyClip = YUP;
OptScl->IntRange[0] = IntRange[0]; OptScl->IntRange[1] = IntRange[1];
}
OptScl->interpmode = interpmode;
OptScl->BrightFact = brfact;
if (MaskZero) OptScl->MaskZero = YUP;
/* map the values in V to the colormap */
/* allocate space for the result */
SV = SUMA_Create_ColorScaledVect(N_V, 0);
if (!SV) {
fprintf (SUMA_STDERR,
"Error %s: Could not allocate for SV.\n", FuncName);
exit(1);
}
/* finally ! */
if (alaAFNI) {
if (LocalHead) {
fprintf (SUMA_STDERR,
"%s: Calling SUMA_ScaleToMap_alaAFNI\n", FuncName);
fprintf (SUMA_STDERR,"%s: arange = %f\n", FuncName, arange);
}
if (CM->frac) {
if (CM->frac[0] > 0 && CM->Sgn == -1) {
SUMA_S_Err ("Color map fractions positive with -anr option");
exit(1);
}
if (CM->frac[0] < 0 && CM->Sgn == 1) {
SUMA_S_Err ("Color map fractions negative with -apr option");
exit(1);
}
}
if (Sgn) {
if (Sgn != CM->Sgn) {
SUMA_S_Warn ("Mixing positive maps (all fractions > 0) "
"with -anr option\n"
"or vice versa. That is allowed but know what"
" you're doing.\n");
}
}
if (!SUMA_ScaleToMap_alaAFNI (V, N_V, arange, CM, OptScl, SV)) {
fprintf (SUMA_STDERR,
"Error %s: Failed in SUMA_ScaleToMap_alaAFNI.\n", FuncName);
exit(1);
}
} else {
if (LocalHead)
fprintf (SUMA_STDERR,"%s: Calling SUMA_ScaleToMap\n", FuncName);
if (!SUMA_ScaleToMap (V, N_V, Vmin, Vmax, CM, OptScl, SV)) {
fprintf (SUMA_STDERR,
"Error %s: Failed in SUMA_ScaleToMap.\n", FuncName);
exit(1);
}
}
/* Now write the colored vector back to disk */
if (NoMaskCol) {
for (k=0; k < N_V; ++k) {
k3 = 3*k;
if (!SV->isMasked[k])
fprintf (SUMA_STDOUT, "%d %f %f %f\n",
iV[k], SV->cV[k3 ], SV->cV[k3+1], SV->cV[k3+2]);
}
} else {
for (k=0; k < N_V; ++k) {
k3 = 3*k;
fprintf (SUMA_STDOUT, "%d %f %f %f\n",
iV[k], SV->cV[k3 ], SV->cV[k3+1], SV->cV[k3+2]);
}
}
/* freeing time */
if (V) SUMA_free(V);
if (iV) SUMA_free(iV);
if (!FromAFNI && freecm) if (CM) SUMA_Free_ColorMap (CM); /* only free CM if
it was a pointer copy from a map in SAC */
if (OptScl) SUMA_free(OptScl);
if (SV) SUMA_Free_ColorScaledVect (SV);
#if 0
if (SAC) SAC = SUMA_DestroyAfniColors(SAC); /* destroy SAC */
#else
SAC = NULL; /* freeing is done in SUMAg_CF */
#endif
SUMA_Free_CommonFields(SUMAg_CF);
SUMA_RETURN (0);
}
int main(int argc, char **argv)
{
static char FuncName[]={"3dGenFeatureDist"};
SEG_OPTS *Opt=NULL;
char *atr=NULL, sbuf[512], *methods=NULL;
int cc, /* class counter */
kk, /* key counter */
aa, /* feature counter */
nn, /* sub-brick index */
vv, /* voxel index */
ss, /* subjects counter */
iii, /* dummy counter */
nbins, /* number of bins */
*ifeat=NULL, key,
**N_alloc_FCset=NULL, /* Number of values allocated for each
vector in FCset */
**N_FCset=NULL, /* Number of filled values for each vector in FCset */
N_ffalloc=0, N_ff, isneg=0,
missfeatwarn=-1 /* Missing feature warning for some subject */;
float fsf=0.0, fsb=0.0,
***FCset=NULL, /* Table holding samples for each feature/class combo */
hrange[2]={-3.0, 3.0}, bwidth1=0.05, bwidth=0.0,
*ff=NULL;
short *sf=NULL, *sb=NULL;
byte **masks=NULL;
SUMA_HIST ***hh=NULL, **hf=NULL;
double ff_m, ff_s;
SUMA_Boolean LocalHead = NOPE;
SUMA_STANDALONE_INIT;
SUMA_mainENTRY;
SUMAg_DOv = SUMA_Alloc_DisplayObject_Struct (SUMA_MAX_DISPLAYABLE_OBJECTS);
Opt = GenFeatureDist_Default(argv, argc);
Opt = GenFeatureDist_ParseInput (Opt, argv, argc);
Opt->hist = tross_commandline( FuncName , argc , argv ) ;
if (!GenFeatureDist_CheckOpts(Opt)) {
ERROR_exit("Failed on option check");
}
/* labeltable? */
if (Opt->labeltable_name) {
Dtable *vl_dtable=NULL;
char *labeltable_str=NULL;
/* read the table */
if (!(labeltable_str = AFNI_suck_file( Opt->labeltable_name))) {
ERROR_exit("Failed to read %s", Opt->labeltable_name);
}
if (!(vl_dtable = Dtable_from_nimlstring(labeltable_str))) {
ERROR_exit("Could not parse labeltable");
}
/* make sure all classes are in the labeltable */
for (cc=0; cc<Opt->clss->num; ++cc) {
if ((key = SUMA_KeyofLabel_Dtable(vl_dtable, Opt->clss->str[cc]))<0){
ERROR_exit("Key not found in %s for %s ",
Opt->labeltable_name, Opt->clss->str[cc]);
}
if (Opt->keys) {
if (Opt->keys[cc]!=key) {
ERROR_exit("Key mismatch %d %d", Opt->keys[cc], key);
}
}
}
if (!Opt->keys) { /* get them from table */
Opt->keys = (int *)calloc(Opt->clss->num, sizeof(int));
for (cc=0; cc<Opt->clss->num; ++cc) {
if ((key = SUMA_KeyofLabel_Dtable(vl_dtable, Opt->clss->str[cc]))<0){
ERROR_exit("(should noy happen) Key not found in %s for %s ",
Opt->labeltable_name, Opt->clss->str[cc]);
}
Opt->keys[cc] = key;
}
}
destroy_Dtable(vl_dtable); vl_dtable=NULL;
}
if (!Opt->keys) {
/* add default keys */
SUMA_S_Note("Keys not available, assuming defaults");
Opt->keys = (int *)calloc(Opt->clss->num, sizeof(int));
for (cc=0; cc<Opt->clss->num; ++cc) {
Opt->keys[cc] = cc+1;
}
}
/* Show the match between keys and classes */
SUMA_ShowClssKeys(Opt->clss->str, Opt->clss->num, Opt->keys);
/* For each feature, each class, collect the values */
SUMA_S_Notev("Collecting data from %d subjects\n", Opt->sig_names->num);
missfeatwarn = -1;
for (ss=0; ss<Opt->sig_names->num; ++ss) { /* for each subject */
/* load the input data */
if (!(Opt->sig = Seg_load_dset( Opt->sig_names->str[ss] ))) {
exit(1);
}
if (Opt->debug > 1) {
SUMA_S_Notev("Have %d sub-bricks in signatures of dude %d\n",
DSET_NVALS(Opt->sig), ss);
}
if (ss == 0) { /* some setup based on initial grid */
if (!Opt->feats) { /* create features from signature */
char *allfeats=NULL;
for (nn=0; nn<DSET_NVALS(Opt->sig); ++nn) {
allfeats =
SUMA_append_replace_string(allfeats,
DSET_BRICK_LABEL(Opt->sig,nn),";", 1);
}
Opt->feats = NI_strict_decode_string_list(allfeats,";, ");
SUMA_free(allfeats); allfeats=NULL;
}
SUMA_S_Notev("Have to work with %d classes, %d features\n",
Opt->clss->num, Opt->feats->num);
SUMA_S_Note("Initializing storage");
/* Receptacles for all observations for each feature
and class combination */
FCset = (float ***)SUMA_calloc(Opt->feats->num, sizeof(float **));
N_FCset = (int **)SUMA_calloc(Opt->feats->num, sizeof(int *));
N_alloc_FCset = (int **)SUMA_calloc(Opt->feats->num, sizeof(int *));
ifeat = (int *)SUMA_calloc(Opt->feats->num, sizeof(int));
for (aa=0; aa<Opt->feats->num; ++aa) {
FCset[aa] = (float **)calloc(Opt->clss->num, sizeof(float *));
N_FCset[aa] = (int *)SUMA_calloc(Opt->clss->num, sizeof(int));
N_alloc_FCset[aa] = (int *)SUMA_calloc(Opt->clss->num, sizeof(int));
}
masks = (byte **)SUMA_calloc(Opt->sig_names->num, sizeof (byte *));
/* Fix VoxDbg */
if (Opt->VoxDbg >= 0) {
Vox1D2Vox3D(Opt->VoxDbg,
DSET_NX(Opt->sig), DSET_NX(Opt->sig)*DSET_NY(Opt->sig),
Opt->VoxDbg3);
} else if (Opt->VoxDbg3[0]>=0) {
Opt->VoxDbg = Opt->VoxDbg3[0] +
Opt->VoxDbg3[1]*DSET_NX(Opt->sig) +
Opt->VoxDbg3[2]*DSET_NX(Opt->sig)*DSET_NY(Opt->sig);
}
}
/* allocate for mask which will be non-zero whenever a voxel is in at least 1 mask. It will have the 1st assignment */
masks[ss] = (byte *)SUMA_calloc(DSET_NVOX(Opt->sig), sizeof(byte));
/* create mapping between feature names and sub-briks */
for (aa=0; aa<Opt->feats->num; ++aa) {
ifeat[aa] = 0;
while (ifeat[aa] < DSET_NVALS(Opt->sig) &&
strcmp(DSET_BRICK_LABEL(Opt->sig,ifeat[aa]),
Opt->feats->str[aa])) ++ifeat[aa];
if (ifeat[aa] >= DSET_NVALS(Opt->sig)) ifeat[aa]=-1;
if (Opt->debug > 1) {
SUMA_S_Notev("Have feature %s in sub-brick %d\n",
Opt->feats->str[aa], ifeat[aa]);
}
}
SUMA_S_Notev("Loading sample classes for subject #%d\n", ss);
if (!(Opt->samp = Seg_load_dset( Opt->samp_names->str[ss] ))) {
exit(1);
}
if (THD_dataset_mismatch(Opt->samp, Opt->sig)) {
SUMA_S_Err(
"Grid mismatch between -samp [%dx%dx%d] and \n"
" -sig [%dx%dx%d] volumes for pair #%d\n",
DSET_NX(Opt->samp), DSET_NY(Opt->samp), DSET_NZ(Opt->samp),
DSET_NX(Opt->sig), DSET_NY(Opt->sig), DSET_NZ(Opt->sig), ss);
exit(1);
}
if (Opt->debug > 1) {
SUMA_S_Notev("Have %d sub-bricks in samples of dude %d\n",
DSET_NVALS(Opt->samp), ss);
}
/* Now collect features for each class */
SUMA_S_Note("Collecting features for each class");
for (cc=0; cc<Opt->clss->num; ++cc) {
if (Opt->debug > 1) {
SUMA_S_Notev("Working class %s\n", Opt->clss->str[cc]);
}
key = Opt->keys[cc];
for (nn=0; nn<DSET_NVALS(Opt->samp); ++nn) {
if (Opt->debug > 2) {
SUMA_S_Notev("Looking for key %d for class %s in sb %d\n",
key, Opt->clss->str[cc], nn);
}
sb = (short *)DSET_ARRAY(Opt->samp,nn);
fsb = DSET_BRICK_FACTOR(Opt->samp,nn);
if (fsb == 0.0) fsb = 1.0;
if (fsb != 1.0) {
SUMA_S_Err("Non-integral dset, possibly.");
exit(1);
}
for (vv=0; vv<DSET_NVOX(Opt->samp); ++vv) {
if (sb[vv] == key) {
for (aa=0; aa<Opt->feats->num; ++aa) {
if (ifeat[aa]>-1) {
if (N_alloc_FCset[aa][cc] <= N_FCset[aa][cc]) {
N_alloc_FCset[aa][cc] += 10000;
FCset[aa][cc] =
(float*)SUMA_realloc(FCset[aa][cc],
N_alloc_FCset[aa][cc]*sizeof(float));
}
sf = (short *)DSET_ARRAY(Opt->sig, ifeat[aa]);
fsf = DSET_BRICK_FACTOR(Opt->sig,ifeat[aa]);
if (fsf == 0.0) fsf = 1.0;
FCset[aa][cc][N_FCset[aa][cc]] = sf[vv]*fsf;
++N_FCset[aa][cc];
if (!masks[ss][vv]) {
masks[ss][vv] = (short)key; /* fcfs */
/* in case we exceed short range */
if (masks[ss][vv]) masks[ss][vv] = 1;
}
} else {
if (missfeatwarn != ss) {
SUMA_S_Warnv("Feature %s not found in subject %d\n",
Opt->feats->str[aa], ss);
missfeatwarn = ss;
}
}
}
}
}
}
}
DSET_delete(Opt->sig); Opt->sig=NULL;
DSET_delete(Opt->samp); Opt->samp=NULL;
} /* loop across all subjects */
/* compute histograms of features across all classes and save them */
hf = (SUMA_HIST **)SUMA_calloc(Opt->feats->num, sizeof(SUMA_HIST *));
SUMA_S_Note("Computing histograms of features across all classes");
ff = NULL; N_ffalloc = 0;
for (aa=0; aa<Opt->feats->num; ++aa) {
N_ff=0;
for (cc=0; cc<Opt->clss->num; ++cc) {
N_ff += N_FCset[aa][cc]; /* more than I need because same voxel
can belong to multiple classes, but just
to be safe */
}
if (N_ffalloc < N_ff) {
N_ffalloc = N_ff;
if (ff) SUMA_free(ff); ff=NULL;
if (!(ff = (float*)SUMA_calloc(N_ff, sizeof(float)))) {
SUMA_S_Crit("Failed to allocate");
exit(1);
}
}
N_ff=0; isneg = 0; ff_m=0.0;
for (ss=0; ss<Opt->sig_names->num; ++ss) { /* Once again, unfortunately */
/* load the input data */
if (!(Opt->sig = Seg_load_dset( Opt->sig_names->str[ss] ))) {
exit(1);
}
if (Opt->debug > 1) {
SUMA_S_Notev("Have %d sub-bricks in signatures of dude %d\n",
DSET_NVALS(Opt->sig), ss);
}
if (ifeat[aa]>-1) {
sb = (short *)DSET_ARRAY(Opt->sig,ifeat[aa]);
fsb = DSET_BRICK_FACTOR(Opt->sig,ifeat[aa]);
if (fsb == 0.0) fsb = 1.0;
for (vv=0; vv<DSET_NVOX(Opt->sig); ++vv) {
if (masks[ss][vv]) {
ff[N_ff] = sb[vv]*fsb;
if (ff[N_ff] < 0) ++isneg;
ff_m += ff[N_ff];
++N_ff;
}
}
}
DSET_delete(Opt->sig); Opt->sig=NULL;
}
ff_m /= N_ff; ff_s=0.0;
for (iii=0; iii<N_ff; ++iii) {
ff_s += SUMA_POW2(ff[iii]-ff_m);
}
ff_s = sqrt(ff_s/N_ff);
sprintf(sbuf, "h(%s)",Opt->feats->str[aa]);
/* Check if you have user specified binning specs */
bwidth = -1; nbins = -1;
for (iii=0; iii<Opt->N_hspec; ++iii) {
if (!strcmp(Opt->feats->str[aa], Opt->hspec[iii]->label)) {
hrange[0] = Opt->hspec[iii]->min;
hrange[1] = Opt->hspec[iii]->max;
nbins = Opt->hspec[iii]->K;
bwidth = 0;
methods = "hands off sir";
break;
}
}
if (bwidth < 0) {
int nmatch = -1;
/* Check the wildcard option */
for (iii=0; iii<Opt->N_hspec; ++iii) {
if ((nmatch = SUMA_is_wild_hspec_label(Opt->hspec[iii]->label))>=0) {
if (!nmatch || !strncmp(Opt->feats->str[aa],
Opt->hspec[iii]->label, nmatch)) {
SUMA_S_Note("Feature %s matched with hspec %s\n",
Opt->feats->str[aa], Opt->hspec[iii]->label);
hrange[0] = Opt->hspec[iii]->min;
hrange[1] = Opt->hspec[iii]->max;
nbins = Opt->hspec[iii]->K;
bwidth = 0;
methods = "hands woff sir";
break;
}
}
}
}
if (bwidth < 0) { /* no user specs found */
nbins = 0;
methods = "Range|OsciBinWidth";
if ((float)isneg/(float)N_ff*100.0 > 1.0) {
hrange[0] = ff_m-3*ff_s;
hrange[1] = ff_m+3*ff_s;
bwidth = bwidth1*ff_s;
} else if (ff_m-3*ff_s > 0) {
hrange[0] = ff_m-3*ff_s;
hrange[1] = ff_m+3*ff_s;
bwidth = bwidth1*ff_s;
} else {
hrange[0] = 0;
hrange[1] = 6.0*ff_s/2.0;
bwidth = bwidth1*ff_s/2.0;
}
}
SUMA_S_Notev("Feature %s: mean %f, std %f\n"
"Hist params: [%f %f], binwidth %f\n",
Opt->feats->str[aa], ff_m, ff_s,
hrange[0], hrange[1], bwidth);
if (!(hf[aa] = SUMA_hist_opt(ff, N_ff, nbins, bwidth, hrange, sbuf, 1,
0.1, methods))) {
SUMA_S_Errv("Failed to generate histogram for %s. \n"
"This will cause trouble at classification.\n",
Opt->feats->str[aa]);
} else {
if ((float)hf[aa]->N_ignored/(float)hf[aa]->n > 0.05) {
SUMA_S_Warnv("For histogram %s, %.2f%% of the samples were\n"
"ignored for being outside the range [%f %f]\n",
Opt->feats->str[aa],
100*(float)hf[aa]->N_ignored/(float)hf[aa]->n,
hf[aa]->min, hf[aa]->max);
}
if (Opt->debug > 1) SUMA_Show_hist(hf[aa], 1, NULL);
/* save the histogram */
if (!SUMA_write_hist(hf[aa],
SUMA_hist_fname(Opt->proot,
Opt->feats->str[aa], NULL, 0))) {
SUMA_S_Errv("Failed to write histog to %s\n", sbuf);
}
}
}
if (ff) SUMA_free(ff); ff = NULL;
/* Compute histograms of features per class && save them*/
hh = (SUMA_HIST ***)SUMA_calloc(Opt->feats->num, sizeof(SUMA_HIST **));
for (aa=0; aa<Opt->feats->num; ++aa) {
hh[aa] = (SUMA_HIST **)SUMA_calloc(Opt->clss->num, sizeof(SUMA_HIST *));
}
SUMA_S_Note("Computing histograms of features per class");
for (cc=0; cc<Opt->clss->num; ++cc) {
if (N_FCset[0][cc] < 10) {
SUMA_S_Errv("Requested class %s (%d) has just %d samples.\n"
"Not enough to grease your pan.\n",
Opt->clss->str[cc], Opt->keys[cc], N_FCset[0][cc]);
exit(1);
}
for (aa=0; aa<Opt->feats->num; ++aa) {
sprintf(sbuf, "h(%s|%s)",Opt->feats->str[aa], Opt->clss->str[cc]);
hrange[0] = hf[aa]->min; hrange[1] = hf[aa]->max;
/* Do not optimize hist range and binwidth anymore,
but allow smoothing. This is needed when a particular
class has very few samples */
if (!(hh[aa][cc] = SUMA_hist_opt(FCset[aa][cc], N_FCset[aa][cc],
hf[aa]->K, hf[aa]->W,
hrange, sbuf, 1,
0.1, "OsciSmooth"))) {
SUMA_S_Errv("Failed to generate histogram for %s|%s. \n"
"This will cause trouble at classification.\n",
Opt->feats->str[aa], Opt->clss->str[cc])
} else {
if (Opt->debug > 1) SUMA_Show_hist(hh[aa][cc], 1, NULL);
/* save the histogram */
if (!SUMA_write_hist(hh[aa][cc],
SUMA_hist_fname(Opt->proot,
Opt->feats->str[aa], Opt->clss->str[cc], 0))) {
SUMA_S_Errv("Failed to write histog to %s\n", sbuf);
}
}
}
}
SUMA_S_Note("Computing Correlation matrices");
/* L2 normalize all of FCset */
for (cc=0; cc<Opt->clss->num; ++cc) {
for (aa=0; aa<Opt->feats->num; ++aa) {
THD_normalize(N_FCset[aa][cc], FCset[aa][cc]);
}
}
{
NI_element **CC=NULL;
float *fm=NULL, *fn=NULL;
NI_element *nel = NULL;
int suc;
/* Compute the correlation matrices for each class */
CC = (NI_element **) SUMA_calloc(Opt->clss->num, sizeof(NI_element *));
for(cc=0; cc<Opt->clss->num; ++cc) {
sprintf(sbuf, "CorrMat(%s)", Opt->clss->str[cc]);
CC[cc] = NI_new_data_element(sbuf, Opt->feats->num);
NI_set_attribute(CC[cc],"Measure","correlation");
atr = SUMA_NI_str_ar_2_comp_str(Opt->feats, " ; ");
NI_set_attribute(CC[cc],"ColumnLabels", atr);SUMA_free(atr); atr = NULL;
atr = SUMA_HistString (FuncName, argc, argv, NULL);
NI_set_attribute(CC[cc],"CommandLine", atr);SUMA_free(atr); atr = NULL;
for (aa=0; aa<Opt->feats->num; ++aa) {
NI_add_column_stride ( CC[cc], NI_FLOAT, NULL, 1 );
}
for (aa=0; aa<Opt->feats->num; ++aa) {
fm = (float*)CC[cc]->vec[aa];
for (iii=0; iii<aa; ++iii) fm[iii] = 0.0; /* will fill later */
fm[aa]=1.0;
for (iii=aa+1; iii<Opt->feats->num; ++iii) {
if (N_FCset[aa][cc]!=N_FCset[iii][cc]) {
SUMA_S_Errv("Sanity check failed, %d != %d\n",
N_FCset[aa][cc], N_FCset[iii][cc]);
}
SUMA_DOTP_VEC(FCset[aa][cc], FCset[iii][cc],
fm[iii], N_FCset[aa][cc],
float, float);
}
}
/* Now fill the remainder */
for (aa=0; aa<Opt->feats->num; ++aa) {
fm = (float*)CC[cc]->vec[aa];
for (iii=0; iii<aa; ++iii) {
fn = (float*)CC[cc]->vec[iii];
fm[iii] = fn[aa];
}
}
snprintf(sbuf, 510, "file:%s.niml.cormat",
SUMA_corrmat_fname(Opt->proot, Opt->clss->str[cc], 0));
NEL_WRITE_TXH(CC[cc], sbuf, suc);
}
}
/* free everything */
if (FCset) {
for (aa=0; aa<Opt->feats->num; ++aa) {
for (cc=0; cc<Opt->clss->num; ++cc) {
if (FCset[aa][cc]) SUMA_free(FCset[aa][cc]);
}
SUMA_free(FCset[aa]);
}
SUMA_free(FCset); FCset=NULL;
}
if (N_FCset) {
for (aa=0; aa<Opt->feats->num; ++aa) {
SUMA_free(N_FCset[aa]);
}
SUMA_free(N_FCset); N_FCset=NULL;
}
if (N_alloc_FCset) {
for (aa=0; aa<Opt->feats->num; ++aa) {
SUMA_free(N_alloc_FCset[aa]);
}
SUMA_free(N_alloc_FCset); N_alloc_FCset=NULL;
}
if (ifeat) SUMA_free(ifeat); ifeat=NULL;
if (hh) {
for (aa=0; aa<Opt->feats->num; ++aa) {
for (cc=0; cc<Opt->clss->num; ++cc) {
if (hh[aa][cc]) hh[aa][cc] = SUMA_Free_hist(hh[aa][cc]);
}
SUMA_free(hh[aa]);
}
SUMA_free(hh); hh=NULL;
}
if (hf) {
for (aa=0; aa<Opt->feats->num; ++aa) {
if (hf[aa]) hf[aa] = SUMA_Free_hist(hf[aa]);
}
SUMA_free(hf); hf=NULL;
}
if (masks) {
for (ss=0; ss<Opt->sig_names->num; ++ss) {
if (masks[ss]) SUMA_free(masks[ss]);
}
masks[ss]=NULL;
}
SUMA_S_Notev("\n"
"Consider running this script to examine the distributions:\n"
" @ExamineGenFeatDists -fdir %s -odir %s\n",
Opt->proot, Opt->proot);
/* all done, free */
Opt = free_SegOpts(Opt);
PRINT_COMPILE_DATE ; exit(0);
}
SUMA_DSET *calcWithOffsets(SUMA_SurfaceObject *SO, SUMA_KUBATEST_OPTIONS* Opt)
{
static char FuncName[]={"calcWithOffsets"};
/* initialize OffS */
SUMA_GET_OFFSET_STRUCT *OffS = SUMA_Initialize_getoffsets (SO->N_Node);
struct timeval start_time, start_time_all;
float etime_GetOffset, etime_GetOffset_all;
float *gD=NULL, *pD=NULL, *rD=NULL;
int *Pr=NULL, *Nd=NULL, *Lj=NULL;
float pathD = 0;/*shortest distance along surface to node ii*/
float geomD = 0;/*geometric distance to node ii*/
float ratio = 1;
int i = 0, j = 0, ii = 0, lj =0;
float x1, x2 , y1, y2, z1, z2, dx, dy, dz, d1, d2, r;
FILE* outFile = NULL, *segDO=NULL;
SUMA_DSET *dset=NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
if (Opt->outfile) {
if (!(outFile = fopen(Opt->outfile, "w"))) {
SUMA_S_Errv("Failed to open %s for writing.\n",
Opt->outfile);
SUMA_RETURN(NULL);
}
fprintf(outFile,
"#Col. 0 Node index\n"
"#Col. 1 Node for which the ratio in 4 is the largest. "
" (Companion of Node in Col.0)\n"
"#Col. 2 distance in 3D\n"
"#Col. 3 shortest surface path\n"
"#Col. 4 Ratio of path/distance\n"
"#Col. 5 Neighborhood layer of node in Col.1, "
" i.e. Neighborhood layer of the companion of node in Col.0");
if (Opt->histnote) {
fprintf(outFile, "#History:%s\n", Opt->histnote);
}
}
if (Opt->segdo) {
if (!(segDO = fopen(Opt->segdo, "w"))) {
SUMA_S_Errv("Failed to open %s for writing.\n",
Opt->segdo);
SUMA_RETURN(NULL);
}
fprintf(segDO,
"#node-based_segments\n");
if (Opt->histnote) {
fprintf(segDO, "#History:%s\n", Opt->histnote);
}
}
Nd=(int *)SUMA_calloc(SO->N_Node, sizeof(int));
Pr=(int *)SUMA_calloc(SO->N_Node, sizeof(int));
Lj=(int *)SUMA_calloc(SO->N_Node, sizeof(int));
gD=(float *)SUMA_calloc(SO->N_Node, sizeof(float));
pD=(float *)SUMA_calloc(SO->N_Node, sizeof(float));
rD=(float *)SUMA_calloc(SO->N_Node, sizeof(float));
if (!Pr || !gD || !pD || !rD) {
SUMA_S_Err("Failed to allocate");
SUMA_RETURN(NOPE);
}
SUMA_etime(&start_time_all,0);
for (i=0; i < SO->N_Node; ++i)
{
pathD = 0;/*shortest distance along surface to node ii*/
geomD = 0;/*geometric distance to node ii*/
ratio = 1;
j = 0;
ii = 0;
lj = -1;
/* show me the offset from node 0 */
SUMA_LHv("Calculating offsets from node %d\n", i);
if (i == 0) {
SUMA_etime(&start_time,0);
}
SUMA_getoffsets2 (i, SO, Opt->plimit, OffS, NULL, 0);
if (i == 99) {
etime_GetOffset = SUMA_etime(&start_time,1);
SUMA_LHv("Search to %f mm took %f seconds for %d nodes.\n"
"Projected completion time: %f minutes\n",
Opt->plimit, etime_GetOffset, i+1,
etime_GetOffset * SO->N_Node / 60.0 / (i+1));
}
/*find smallest ratio*/
for (j=0; j < OffS->N_Nodes; j++)
{
if( i!=j && OffS->LayerVect[j] >= 0)
{
x1 = SO->NodeList[i*3+0];
x2 = SO->NodeList[j*3+0];
y1 = SO->NodeList[i*3+1];
y2 = SO->NodeList[j*3+1];
z1 = SO->NodeList[i*3+2];
z2 = SO->NodeList[j*3+2];
dx = x1 - x2;
dy = y1 - y2;
dz = z1 - z2;
d1 = OffS->OffVect[j];
d2 = sqrt(dx*dx + dy*dy + dz*dz);
r = d1 / d2;
if ( d2 < Opt->dlimit && d1 < Opt->plimit && r > ratio )
{
if (r > 1000) {
SUMA_S_Notev("Extreme Ratio:\n"
"node=%d (%f %f %f), paired with node %d (%f %f %f)\n"
" geo_dist=%f Euc_dist=%f r=%f layer=%d\n",
i, x1, y1, z1,
j, x2, y2, z2,
d1, d2, r, OffS->LayerVect[j]);
}
ratio = r;
ii = j;
lj = OffS->LayerVect[j];
pathD = d1;
geomD = d2;
}
}
}
Nd[i] = i;
Pr[i] = ii;
Lj[i] = lj;
gD[i] = geomD;
pD[i] = pathD;
rD[i] = ratio;
if (outFile)
fprintf(outFile, "%i\t%i\t%f\t%f\t%f\t%d\n",
i, ii, geomD, pathD, ratio, lj);
if (segDO) {
float r,g,b,a;
SUMA_RAND_COL(i?-1:0,r,g,b,a);
fprintf(segDO, "%i\t%i\t%f %f %f %f\n", i, ii, r,g,b,1.0);
}
if (LocalHead)
fprintf(SUMA_STDERR,"%s: Recycling OffS\n", FuncName);
SUMA_Recycle_getoffsets (OffS);
if (LocalHead)
fprintf(SUMA_STDERR,"%s: Done.\n", FuncName);
}
if (outFile) fclose(outFile);
if (segDO) fclose(segDO);
dset = SUMA_CreateDsetPointer(Opt->prefix, SUMA_NODE_BUCKET,
NULL, SO->idcode_str,
SO->N_Node);
if (!SUMA_AddDsetNelCol(dset, "node index", SUMA_NODE_INDEX, Nd, NULL, 1)) {
SUMA_S_Err("Failed to add new data");
SUMA_FreeDset(dset); SUMA_RETURN(NULL);
}
if (!SUMA_AddDsetNelCol(dset, "PairingNode", SUMA_NODE_INT, Pr, NULL, 1)) {
SUMA_S_Err("Failed to add new data");
SUMA_FreeDset(dset); SUMA_RETURN(NULL);
}
if (!SUMA_AddDsetNelCol(dset, "LayerOfPairNode", SUMA_NODE_INT, Lj, NULL, 1)){
SUMA_S_Err("Failed to add new data");
SUMA_FreeDset(dset); SUMA_RETURN(NULL);
}
if (!SUMA_AddDsetNelCol(dset, "Eucl.Dist", SUMA_NODE_FLOAT, gD, NULL, 1)) {
SUMA_S_Err("Failed to add new data");
SUMA_FreeDset(dset); SUMA_RETURN(NULL);
}
if (!SUMA_AddDsetNelCol(dset, "Geo.Dist",SUMA_NODE_FLOAT, pD, NULL, 1)) {
SUMA_S_Err("Failed to add new data");
SUMA_FreeDset(dset); SUMA_RETURN(NULL);
}
if (!SUMA_AddDsetNelCol(dset, "G/E.Dist",SUMA_NODE_FLOAT, rD, NULL, 1)) {
SUMA_S_Err("Failed to add new data");
SUMA_FreeDset(dset); SUMA_RETURN(NULL);
}
etime_GetOffset_all = SUMA_etime(&start_time_all,1);
SUMA_S_Notev("Done.\nSearch to %f mm took %f minutes for %d nodes.\n" ,
Opt->plimit, etime_GetOffset_all / 60.0 , SO->N_Node);
SUMA_Free_getoffsets(OffS);
SUMA_free(Nd); Nd = NULL;
SUMA_free(Pr); Pr = NULL;
SUMA_free(Lj); Lj = NULL;
SUMA_free(gD); gD = NULL;
SUMA_free(pD); pD = NULL;
SUMA_free(rD); rD = NULL;
SUMA_RETURN(dset);
}
SUMA_GENERIC_PROG_OPTIONS_STRUCT *SUMA_prompt_user_ParseInput(
char *argv[], int argc, SUMA_GENERIC_ARGV_PARSE *ps)
{
static char FuncName[]={"SUMA_prompt_user_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->ps = ps; /* just hold it there for convenience */
Opt->ps = ps; /* for convenience */
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) {
ps->hverb = 1;
usage_prompt_user(ps);
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], "-pause") == 0))
{
if (kar+1 >= argc)
{
fprintf (SUMA_STDERR, "need a string after -pause \n");
exit (1);
}
Opt->b1 = 1;
Opt->in_name = argv[++kar];
brk = YUP;
if (!strcmp(Opt->in_name, "-")) Opt->in_name = read_file_text(stdin);
}
if (!brk && !ps->arg_checked[kar]) {
SUMA_S_Errv("Option %s not understood.\n"
"Try -help for usage\n",
argv[kar]);
exit (1);
} else {
brk = NOPE;
kar ++;
}
}
SUMA_RETURN(Opt);
}
char * SUMA_BrainVoyager_Read_vmr(char *fnameorig, THD_3dim_dataset *dset, int LoadData,
byte Qxforce, byte bsforce, int viewforce, char *outname)
{
static char FuncName[]={"SUMA_BrainVoyager_Read_vmr"};
int i = 0, nf, iop, dchunk, End, bs, doff, ex,
data_type=SUMA_notypeset, view, endian, dblock;
THD_ivec3 iv3;
unsigned long len;
short qxver;
short nvox[3]; /* values are unsigned, so check for sign for bs... */
THD_mat33 m33;
THD_ivec3 orixyz , nxyz ;
THD_fvec3 dxyz , orgxyz ;
float ep[3], sp[3];
char sview[10], *fname = NULL, *scom=NULL, form[10], swp[10], orstr[10], xfov[100], yfov[100], zfov[100], *prefix = NULL, *dsetheadname = NULL;
FILE *fid = NULL;
SUMA_Boolean LocalHead = NOPE;
SUMA_ENTRY;
if (!dset || !fnameorig) {
SUMA_SL_Err("NULL fname || NULL dset!");
SUMA_RETURN(NOPE);
}
if (!SUMA_isExtension(fnameorig, ".vmr")) {
SUMA_SL_Err("vmr dset is expected to have .vmr for an extension");
SUMA_RETURN(NOPE);
}
if (!SUMA_filexists(fnameorig)) {
SUMA_SL_Err("file does not exist");
SUMA_RETURN(NOPE);
}
/* make fname be the new name without the extension*/
if (!outname) {
fname = SUMA_Extension(fnameorig,".vmr", YUP);
} else {
fname = SUMA_Extension(outname, ".vmr", YUP);
}
prefix = SUMA_AfniPrefix(fname, NULL, NULL, NULL);
if( !THD_filename_ok(prefix) ) {
SUMA_SL_Err("Bad prefix");
goto CLEAN_EXIT;
}
/* someday, guess format on your own...*/
qxver = 0;
if (Qxforce) {
SUMA_LH("Forcing qxver");
qxver = 1; /* set to 1 if qx format */
}
/* view ? */
SUMA_LHv("Viewforce = %d; [%d %d]\n", viewforce, VIEW_ORIGINAL_TYPE, VIEW_TALAIRACH_TYPE);
if (viewforce >= VIEW_ORIGINAL_TYPE && viewforce <= VIEW_TALAIRACH_TYPE) {
view = viewforce;
} else {
view = VIEW_ORIGINAL_TYPE;
if (SUMA_iswordin_ci(fnameorig, "_tal") == 1) { view = VIEW_TALAIRACH_TYPE; }
else if (SUMA_iswordin_ci(fnameorig, "_acpc") == 1) { view = VIEW_ACPCALIGNED_TYPE; }
else { view = VIEW_ORIGINAL_TYPE; }
}
switch (view) {
case VIEW_ORIGINAL_TYPE:
sprintf(sview,"+orig"); break;
case VIEW_ACPCALIGNED_TYPE:
sprintf(sview,"+acpc"); break;
case VIEW_TALAIRACH_TYPE:
sprintf(sview,"+tlrc"); break;
default:
SUMA_SL_Err("Bad view");
goto CLEAN_EXIT;
}
if (LocalHead) fprintf(SUMA_STDERR,"%s: View %s, %d\n", FuncName, sview, view);
dsetheadname = SUMA_append_replace_string(prefix,".HEAD", sview, 0);
if (SUMA_filexists(dsetheadname)) {
SUMA_S_Errv("Bad prefix, output dset %s exists\n", dsetheadname);
goto CLEAN_EXIT;
}
SUMA_free(dsetheadname); dsetheadname = NULL;
fid = fopen(fnameorig,"r");
if (!fid) {
SUMA_SL_Err("Could not open file for reading");
goto CLEAN_EXIT;
}
if (qxver) {
SUMA_LH("Reading dimensions, 2+ 1st 6 bytes and deciding on swap");
doff = 4*sizeof(short);/* data offset 2 + 6 bytes */
} else {
SUMA_LH("Reading dimensions, 1st 6 bytes and deciding on swap");
doff = 3*sizeof(short);/* data offset */
}
SUMA_WHAT_ENDIAN(endian);
bs = 0;
swp[0] = '\0';
data_type = SUMA_byte; /* voxel data is bytes */
dchunk = sizeof(byte); /* voxel data is bytes */
sprintf(form,"3Db");
if (qxver) { SUMA_READ_NUM(&(qxver), fid, ex, sizeof(short)); if (LocalHead) fprintf(SUMA_STDERR,"%s: QXver = %d\n", FuncName, qxver);}/* is this a QX format?*/
SUMA_READ_NUM(&(nvox[2]), fid, ex, sizeof(short)); /* Z first */
SUMA_READ_NUM(&(nvox[1]), fid, ex, sizeof(short));
SUMA_READ_NUM(&(nvox[0]), fid, ex, sizeof(short));
if ((nvox[0] < 0 || nvox[1] < 0 || nvox[2] < 0 )) {
SUMA_LH("Byte swapping needed");
bs = 1;
}
if (bsforce) {
SUMA_LH("Byte swapping forced");
bs = 1;
}
if (bs) {
if (qxver) SUMA_swap_2(&(qxver));
SUMA_swap_2(&(nvox[0]));
SUMA_swap_2(&(nvox[1]));
SUMA_swap_2(&(nvox[2]));
sprintf(swp,"-2swap");
SUMA_OTHER_ENDIAN(endian);
}
/* 1 1 1???? */
if (nvox[0] == nvox[1] && nvox[1] == nvox[2] && nvox[2] == 1) {
if (LocalHead) { fprintf(SUMA_STDERR,"Warning %s: Voxel nums all 1. Trying from file size\n", FuncName); }
len = THD_filesize( fnameorig ) ;
len -= doff;
len /= dchunk;
nvox[0] = (int)pow((double)len, 1.0/3.0);
if (nvox[0] * nvox[0] * nvox[0] != len) {
fprintf(SUMA_STDERR,"Error %s: Bad voxel numbers and could not infer number from filesize.\n"
"Size of file: %lld, data offset: %d, datum size: %d, data number: %ld\n"
"Inferred nvox:%d\n",
FuncName,
THD_filesize( fnameorig ), doff, dchunk, len,
nvox[0]);
goto CLEAN_EXIT;
}
nvox[2] = nvox[1] = nvox[0];
if (LocalHead) { fprintf(SUMA_STDERR,"Warning %s: Using filesize inferred number of voxels: %d %d %d\n",
FuncName, nvox[0], nvox[1], nvox[2]); }
}
if (LocalHead) fprintf(SUMA_STDERR,"Number of voxels: %d %d %d. qxver %d\n", nvox[0], nvox[1], nvox[2], qxver);
/* check against filesize */
len = THD_filesize( fnameorig ) ;
dblock = nvox[0]*nvox[1]*nvox[2]*dchunk;
if (len != (dblock + doff)) {
if (!qxver) {
fprintf(SUMA_STDERR, "Mismatch between file size %ld\n"
"and expected size %d = (%d*%d*%d*%d+%d) \n",
len, (dblock + doff), nvox[0], nvox[1], nvox[2], dchunk, doff);
goto CLEAN_EXIT;
}else if (len < dblock + doff) {
fprintf(SUMA_STDERR, "Mismatch between file size %ld\n"
"and minimum expected size %d = (%d*%d*%d*%d+%d) \n",
len, (dblock + doff), nvox[0], nvox[1], nvox[2], dchunk, doff);
goto CLEAN_EXIT;
}else {
SUMA_LH("Proceeding");
}
}
if (LocalHead) fprintf(SUMA_STDERR,"File size passes test\n");
/* orientation */
orixyz.ijk[0] = ORI_A2P_TYPE;
orixyz.ijk[1] = ORI_S2I_TYPE;
orixyz.ijk[2] = ORI_R2L_TYPE;
/* load number of voxels */
LOAD_IVEC3( nxyz , nvox[0] , nvox[1] , nvox[2] ) ;
/* form the command */
SUMA_LH("Forming command");
{
float delta[3]={1.0, 1.0, 1.0};
float origin[3]={0.0, 0.0, 0.0};
/* set origin of 0th voxel*/
origin[0] = (float)((nvox[0]*delta[0]))/2.0; /* ZSS: Changed from 0 0 0 Nov 1 07 */
origin[1] = (float)((nvox[1]*delta[1]))/2.0;
origin[2] = (float)((nvox[2]*delta[2]))/2.0;
/* dimensions, same for vmr*/
LOAD_FVEC3( dxyz , delta[0], delta[1], delta[2] ) ;
SUMA_sizeto3d_2_deltaHEAD(orixyz, &dxyz);
/* origin */
LOAD_FVEC3( orgxyz , origin[0], origin[1], origin[2] ) ;
SUMA_originto3d_2_originHEAD(orixyz, &orgxyz);
}
/* start point (edge of origin voxel) and end point (opposite to start ) */
sp[0] = orgxyz.xyz[0] + SUMA_ABS(dxyz.xyz[0]) / 2.0;
sp[1] = orgxyz.xyz[1] + SUMA_ABS(dxyz.xyz[1]) / 2.0;
sp[2] = orgxyz.xyz[2] + SUMA_ABS(dxyz.xyz[2]) / 2.0;
ep[0] = orgxyz.xyz[0] + (nxyz.ijk[0] - 0.5) * SUMA_ABS(dxyz.xyz[0]);
ep[1] = orgxyz.xyz[1] + (nxyz.ijk[1] - 0.5) * SUMA_ABS(dxyz.xyz[1]);
ep[2] = orgxyz.xyz[2] + (nxyz.ijk[2] - 0.5) * SUMA_ABS(dxyz.xyz[2]);
SUMA_orcode_to_orstring (orixyz.ijk[0], orixyz.ijk[1], orixyz.ijk[2], orstr);
sprintf(xfov," -xFOV %.2f%c-%.2f%c", sp[0], orstr[0], ep[0], orstr[3]);
sprintf(yfov," -yFOV %.2f%c-%.2f%c", sp[1], orstr[1], ep[1], orstr[4]);
sprintf(zfov," -zFOV %.2f%c-%.2f%c", sp[2], orstr[2], ep[2], orstr[5]);
scom = (char *)SUMA_calloc((strlen(fnameorig)+500), sizeof(char));
sprintf(scom,"to3d %s %s %s %s -prefix %s %s:%d:0:%d:%d:%d:%s ",
swp, xfov, yfov, zfov, prefix, form, doff,
nvox[0], nvox[1], nvox[0], fnameorig);
SUMA_LH("HERE");
if (dset) { /* form the dset header */
int nvals_read = 0;
SUMA_LH("Filling header");
EDIT_dset_items( dset ,
ADN_prefix , prefix ,
ADN_datum_all , data_type ,
ADN_nxyz , nxyz ,
ADN_xyzdel , dxyz ,
ADN_xyzorg , orgxyz ,
ADN_xyzorient , orixyz ,
ADN_malloc_type , DATABLOCK_MEM_MALLOC ,
ADN_view_type , view ,
ADN_type , HEAD_ANAT_TYPE ,
ADN_func_type , ANAT_BUCK_TYPE ,
ADN_none ) ;
if (LoadData) {
void *vec=NULL;
SUMA_LH("Loading data");
if (!(vec = SUMA_BinarySuck(fnameorig, data_type, endian, 3*sizeof(short), -1, &nvals_read))) {
SUMA_SL_Err("Failed to read data file"); goto CLEAN_EXIT;
}
if (qxver) {
if (nvals_read < nvox[0]*nvox[1]*nvox[2]) {
SUMA_SL_Warn("Failed to read expected number of voxels\n proceeding...");
}
} else {
if (nvals_read != nvox[0]*nvox[1]*nvox[2]) {
SUMA_SL_Warn("Failed to read the appropriate number of voxels\n proceeding...");
}
}
EDIT_substitute_brick( dset , 0 , data_type , vec) ;
if (LocalHead) fprintf(SUMA_STDERR,"%s: Read %d values from file.\n", FuncName, nvals_read);
/* DSET_write(dset) ; */
}
}
CLEAN_EXIT:
if (prefix) SUMA_free(prefix); prefix = NULL;
if (fname) SUMA_free(fname); fname = NULL;
if (fid) fclose(fid); fid = NULL;
SUMA_RETURN(scom);
}
int main (int argc,char *argv[])
{/* Main */
static char FuncName[]={"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);
}
