00001 #include "SUMA_suma.h"
00002 #define MAIN
00003 #include "../afni.h"
00004 #undef MAIN
00005
00006 #ifdef SUMA_MakeColorMap_STAND_ALONE
00007 #define STAND_ALONE
00008 #elif defined SUMA_ScaleToMap_STAND_ALONE
00009 #define STAND_ALONE
00010 #endif
00011
00012 #ifdef STAND_ALONE
00013
00014 SUMA_SurfaceViewer *SUMAg_cSV;
00015 SUMA_SurfaceViewer *SUMAg_SVv;
00016
00017 int SUMAg_N_SVv = 0;
00018 SUMA_DO *SUMAg_DOv;
00019 int SUMAg_N_DOv = 0;
00020 SUMA_CommonFields *SUMAg_CF;
00021 #else
00022 extern SUMA_CommonFields *SUMAg_CF;
00023 extern SUMA_DO *SUMAg_DOv;
00024 extern SUMA_SurfaceViewer *SUMAg_SVv;
00025 extern int SUMAg_N_SVv;
00026 extern int SUMAg_N_DOv;
00027 #endif
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062 SUMA_COLOR_MAP* SUMA_MakeColorMap (float **Fiducials, int Nfid, int Ncols, SUMA_Boolean SkipLast, char *Name)
00063 {
00064 static char FuncName[]={"SUMA_MakeColorMap"};
00065 float **M, dFid[3];
00066 int i, j, Ninter, Ngap, im, Ncolsgood, Npergap;
00067 SUMA_COLOR_MAP * SM;
00068
00069 SUMA_ENTRY;
00070
00071
00072 for (i=0; i < Nfid; ++i) {
00073 for (j=0; j < 3; ++j) {
00074 if (Fiducials[i][j] < 0 || Fiducials[i][j] > 1) {
00075 fprintf (SUMA_STDERR,"Error %s: Fiducial colors must be between 0 & 1 (found %f)\n", FuncName, Fiducials[i][j]);
00076 SUMA_RETURN (NULL);
00077 }
00078 }
00079 }
00080
00081 if (SkipLast) Ninter = Ncols - (Nfid - 1);
00082 else Ninter = Ncols - Nfid;
00083
00084 Ngap = Nfid - 1;
00085
00086
00087 if (Ninter % Ngap) {
00088
00089 if (SkipLast) Ncolsgood = (int)(rint((float)Ninter/Ngap) * Ngap + Nfid + 1);
00090 else Ncolsgood = (int)(rint((float)Ninter/Ngap) * Ngap + Nfid);
00091
00092 fprintf (SUMA_STDERR,"Error %s: The choice of Ncols does not work with the number\nof fiducial colours.\nTry Ncols = %d\n", \
00093 FuncName, Ncolsgood);
00094 SUMA_RETURN (NULL);
00095 }
00096
00097
00098 M = (float **)SUMA_allocate2D (Ncols, 3, sizeof(float));
00099 if (M == NULL) {
00100 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for M.\n", FuncName);
00101 SUMA_RETURN (NULL);
00102 }
00103
00104
00105 im = 0;
00106 Npergap = Ninter / Ngap;
00107
00108 for (i=0; i < Ngap; ++i) {
00109 dFid[0] = (Fiducials[i+1][0] - Fiducials[i][0])/(Npergap+1);
00110 dFid[1] = (Fiducials[i+1][1] - Fiducials[i][1])/(Npergap+1);
00111 dFid[2] = (Fiducials[i+1][2] - Fiducials[i][2])/(Npergap+1);
00112
00113
00114 for (j=0; j < Npergap+1; ++ j) {
00115
00116 if (im < Ncols) {
00117 M[im][0] = Fiducials[i][0] + j*dFid[0];
00118 M[im][1] = Fiducials[i][1] + j*dFid[1];
00119 M[im][2] = Fiducials[i][2] + j*dFid[2];
00120
00121 }
00122
00123 ++im;
00124 }
00125 }
00126 if (!SkipLast) {
00127 M[im][0] = Fiducials[Ngap][0];
00128 M[im][1] = Fiducials[Ngap][1];
00129 M[im][2] = Fiducials[Ngap][2];
00130 }
00131
00132
00133 SM = (SUMA_COLOR_MAP *)SUMA_malloc(sizeof(SUMA_COLOR_MAP));
00134 if (SM == NULL) {
00135 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for SM.\n", FuncName);
00136 SUMA_RETURN (NULL);
00137 }
00138
00139 SM->Name = (char *)SUMA_calloc(strlen(Name)+1, sizeof(char));
00140 if (SM->Name == NULL) {
00141 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for SM->Name.\n", FuncName);
00142 SUMA_RETURN (NULL);
00143 }
00144 sprintf(SM->Name, "%s",Name);
00145 SM->M = M;
00146 SM->N_Col = Ncols;
00147
00148 SM->frac = NULL;
00149 SM->cname = NULL;
00150 SM->Sgn = 0;
00151 SM->SO = NULL;
00152
00153 SUMA_RETURN (SM);
00154 }
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184 SUMA_COLOR_MAP* SUMA_MakeColorMap_v2 (float **Fiducials, int Nfid, int *Nint, SUMA_Boolean SkipLast, char *Name)
00185 {
00186 static char FuncName[]={"SUMA_MakeColorMap_v2"};
00187 float **M, dFid[3];
00188 int i, j, im, Ncols;
00189 SUMA_COLOR_MAP * SM;
00190
00191 SUMA_ENTRY;
00192
00193
00194 if (Nint[0]) {
00195 fprintf (SUMA_STDERR,"Error %s: The index of the first color (%d) must be 0, indexing starts at 0 not 1.\n", FuncName, Nint[0]);
00196 SUMA_RETURN (NULL);
00197 }
00198 for (i=0; i < Nfid; ++i) {
00199 for (j=0; j < 3; ++j) {
00200 if (Fiducials[i][j] < 0 || Fiducials[i][j] > 1) {
00201 fprintf (SUMA_STDERR,"Error %s: Fiducial colors must be between 0 & 1 (found %f)\n", FuncName, Fiducials[i][j]);
00202 SUMA_RETURN (NULL);
00203 }
00204 }
00205 }
00206
00207 Ncols = Nint[Nfid-1]+1;
00208
00209 if (SkipLast) Ncols = Ncols - 1;
00210
00211
00212 M = (float **)SUMA_allocate2D (Ncols, 3, sizeof(float));
00213 if (M == NULL) {
00214 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for M.\n", FuncName);
00215 SUMA_RETURN (NULL);
00216 }
00217
00218
00219 im = 0;
00220 for (i=0; i < Nfid-1; ++i) {
00221 dFid[0] = (Fiducials[i+1][0] - Fiducials[i][0])/(Nint[i+1]-Nint[i]);
00222 dFid[1] = (Fiducials[i+1][1] - Fiducials[i][1])/(Nint[i+1]-Nint[i]);
00223 dFid[2] = (Fiducials[i+1][2] - Fiducials[i][2])/(Nint[i+1]-Nint[i]);
00224
00225
00226 for (j=0; j < (Nint[i+1]- Nint[i]); ++ j) {
00227
00228 M[im][0] = Fiducials[i][0] + j*dFid[0];
00229 M[im][1] = Fiducials[i][1] + j*dFid[1];
00230 M[im][2] = Fiducials[i][2] + j*dFid[2];
00231
00232
00233 ++im;
00234 }
00235 }
00236
00237 if (!SkipLast){
00238 M[im][0] = Fiducials[Nfid-1][0];
00239 M[im][1] = Fiducials[Nfid-1][1];
00240 M[im][2] = Fiducials[Nfid-1][2];
00241 }
00242
00243
00244 SM = (SUMA_COLOR_MAP *)SUMA_malloc(sizeof(SUMA_COLOR_MAP));
00245 if (SM == NULL) {
00246 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for SM.\n", FuncName);
00247 SUMA_RETURN (NULL);
00248 }
00249
00250 SM->Name = (char *)SUMA_calloc(strlen(Name)+1, sizeof(char));
00251 if (SM->Name == NULL) {
00252 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for SM->Name.\n", FuncName);
00253 SUMA_RETURN (NULL);
00254 }
00255 sprintf(SM->Name, "%s",Name);
00256 SM->M = M;
00257 SM->N_Col = Ncols;
00258
00259 SM->frac = NULL;
00260 SM->cname = NULL;
00261 SM->Sgn = 0;
00262 SM->SO = NULL;
00263 SUMA_RETURN (SM);
00264 }
00265
00266
00267 void SUMA_Free_ColorMap (SUMA_COLOR_MAP* SM)
00268 {
00269 static char FuncName[]={"SUMA_Free_ColorMap"};
00270 int i = 0;
00271
00272 SUMA_ENTRY;
00273
00274 if (SM->Name) SUMA_free(SM->Name);
00275 if (SM->M) SUMA_free2D((char **)SM->M, SM->N_Col);
00276 if (SM->cname) {
00277 for (i=0; i<SM->N_Col; ++i) { if (SM->cname[i]) SUMA_free(SM->cname[i]); }
00278 SUMA_free(SM->cname);
00279 }
00280 if (SM->frac) SUMA_free(SM->frac);
00281 if (SM->SO) SUMA_Free_Surface_Object(SM->SO);
00282
00283 if (SM) SUMA_free(SM);
00284
00285 SUMA_RETURNe;
00286 }
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299 SUMA_AFNI_COLORS *SUMA_Get_AFNI_Default_Color_Maps ()
00300 {
00301 static char FuncName[]={"SUMA_Get_AFNI_Default_Color_Maps"};
00302 float rgb[3];
00303 SUMA_RGB_NAME *Cv = NULL;
00304 SUMA_COLOR_MAP **CMv=NULL;
00305 SUMA_COLOR_MAP *CMp=NULL, *CMn=NULL;
00306 SUMA_AFNI_COLORS *SAC=NULL;
00307 int i, j, icol;
00308 int N_maps, N_cols;
00309 int ival , ii,jj ;
00310 float fval ;
00311 float pthr[NPANE_MAX+1] ;
00312 int pov[NPANE_MAX+1] ;
00313 char *homeenv=NULL, *sumarc=NULL;
00314 struct stat stbuf;
00315 SUMA_Boolean LocalHead_Detail = NOPE;
00316 SUMA_Boolean LocalHead = NOPE;
00317
00318 SUMA_ENTRY;
00319
00320
00321
00322 N_maps = -1;
00323 N_cols = -1;
00324
00325
00326 Cv = SUMA_Add_Color ("none",
00327 -1.0, -1.0, -1.0, 1.0,
00328 Cv, &N_cols);
00329
00330
00331 for (i=0; i<DEFAULT_NCOLOVR; ++i) {
00332 if (!SUMA_Interpret_AFNIColor (INIT_def_colovr[i], rgb)) {
00333 fprintf(SUMA_STDERR,"Error %s: Failed to interpret color %s : %s\n", FuncName, INIT_def_labovr[i], INIT_def_colovr[i]);
00334 } else {
00335 if (LocalHead_Detail) fprintf(SUMA_STDERR,"%s: Adding color...", FuncName);
00336 Cv = SUMA_Add_Color (INIT_def_labovr[i],
00337 rgb[0], rgb[1], rgb[2], 1.0,
00338 Cv, &N_cols);
00339 }
00340 }
00341
00342
00343
00344
00345 for( ii=NPANE_INIT+1 ; ii <= NPANE_MAX ; ii++ ){
00346 fval = 1.0 / ii ;
00347 pthr[0] = 1.0 ;
00348 pthr[ii] = 0.0 ;
00349 for( jj=1 ; jj < ii ; jj++ ) pthr[jj] = fval * (ii-jj) ;
00350 for( jj=0 ; jj < ii ; jj++ ) pov[jj] = (jj % INIT_ncolovr) + 1 ;
00351
00352 for( jj=0 ; jj <= ii ; jj++ ) INIT_pval_pos[ii][jj] = pthr[jj] ;
00353 for( jj=0 ; jj < ii ; jj++ ) INIT_ovin_pos[ii][jj] = pov[jj] ;
00354 }
00355
00356
00357 for( ii=NPANE_INIT+1 ; ii <= NPANE_MAX ; ii++ ){
00358 fval = 1.0 / ii ;
00359 pthr[0] = 1.0 ;
00360 pthr[ii] = -1.0 ;
00361 for( jj=1 ; jj < ii ; jj++ ) pthr[jj] = fval * (ii-2*jj) ;
00362 for( jj=0 ; jj < ii ; jj++ ) pov[jj] = (jj % INIT_ncolovr) + 1 ;
00363
00364 for( jj=0 ; jj <= ii ; jj++ ) INIT_pval_sgn[ii][jj] = pthr[jj] ;
00365 for( jj=0 ; jj < ii ; jj++ ) INIT_ovin_sgn[ii][jj] = pov[jj] ;
00366 }
00367
00368 #if defined(RGBCYC_COUNT) && RGBCYC_COUNT <= NPANE_MAX
00369 ii = RGBCYC_COUNT ;
00370 for( jj=0 ; jj < ii ; jj++ ) INIT_ovin_pos[ii][jj] = RGBCYC_FIRST+jj+1 ;
00371 for( jj=0 ; jj < ii ; jj++ ) INIT_ovin_sgn[ii][jj] = RGBCYC_FIRST+jj+1 ;
00372 #endif
00373
00374
00375
00376 for (i = NPANE_MIN; i<= NPANE_MAX; ++i) {
00377 CMp = (SUMA_COLOR_MAP *)SUMA_malloc(sizeof(SUMA_COLOR_MAP));
00378 CMn = (SUMA_COLOR_MAP *)SUMA_malloc(sizeof(SUMA_COLOR_MAP));
00379 if (CMp == NULL || CMn == NULL) {
00380 SUMA_SL_Crit ("Failed to allocate for CMp &/| CMn.");
00381 SUMA_RETURN(NULL);
00382 }
00383
00384 CMp->SO = NULL;
00385 CMn->SO = NULL;
00386 CMp->cname = NULL;
00387 CMn->cname = NULL;
00388 CMp->N_Col = i;
00389 CMn->N_Col = i;
00390 CMp->Sgn = 1;
00391 CMn->Sgn = -1;
00392
00393 CMp->Name = (char *)SUMA_calloc(25, sizeof(char));
00394 CMn->Name = (char *)SUMA_calloc(25, sizeof(char));
00395 CMp->frac = (float *)SUMA_calloc(i, sizeof(float));
00396 CMn->frac = (float *)SUMA_calloc(i, sizeof(float));
00397 CMp->M = (float**)SUMA_allocate2D (CMp->N_Col, 3, sizeof(float));
00398 CMn->M = (float**)SUMA_allocate2D (CMn->N_Col, 3, sizeof(float));
00399 if ( CMp->frac == NULL || CMn->frac == NULL
00400 || CMp->M == NULL || CMn->M == NULL
00401 || CMp->Name == NULL || CMn->Name == NULL ) {
00402 SUMA_SL_Crit ("Failed to allocate for fields of CMp &/| CMn.");
00403 SUMA_RETURN (NULL);
00404 }
00405
00406 sprintf(CMp->Name, "afni_p%d",i);
00407 sprintf(CMn->Name, "afni_n%d",i);
00408
00409 if (LocalHead_Detail) fprintf (SUMA_STDERR,"%s: Building colormap POS #%d (%s)\n", FuncName, i, CMp->Name);
00410
00411 for ( j = 0; j < i; ++j) {
00412 if (!INIT_ovin_pos[i][j]) {
00413 if (LocalHead_Detail) {
00414 fprintf (SUMA_STDERR,"\t[i%d] NoColor\t%f\n",
00415 INIT_ovin_pos[i][j],
00416 INIT_pval_pos[i][j]);
00417 }
00418 CMp->M[i - j - 1][0] = CMp->M[i - j - 1][1] = CMp->M[i - j - 1][2] = -1.0;
00419 } else {
00420 if (LocalHead_Detail) {
00421 fprintf (SUMA_STDERR,"\t[i%d] %s\t%f\n",
00422 INIT_ovin_pos[i][j],
00423 INIT_def_labovr[INIT_ovin_pos[i][j]-1], INIT_pval_pos[i][j]);
00424 }
00425
00426 icol = SUMA_Find_Color (INIT_def_labovr[INIT_ovin_pos[i][j]-1], Cv, N_cols);
00427 if (icol < 0) {
00428 fprintf (SUMA_STDERR,"Error%s: Failed to find color %s\nUsing no-color in its place\n",
00429 FuncName, INIT_def_labovr[INIT_ovin_pos[i][j]-1]);
00430 CMp->M[i - j - 1][0] = CMp->M[i - j - 1][1] = CMp->M[i - j - 1][2] = -1.0;
00431 } else {
00432 CMp->M[i - j - 1][0] = Cv[icol].r;
00433 CMp->M[i - j - 1][1] = Cv[icol].g;
00434 CMp->M[i - j - 1][2] = Cv[icol].b;
00435 }
00436 }
00437 CMp->frac[i - j - 1] = INIT_pval_pos[i][j];
00438 }
00439
00440
00441 CMv = SUMA_Add_ColorMap (CMp, CMv, &N_maps);
00442 if (!CMv) {
00443 SUMA_SL_Crit("Failed in SUMA_Add_ColorMap");
00444 SUMA_RETURN(NULL);
00445 }
00446
00447 if (LocalHead_Detail) fprintf (SUMA_STDERR,"%s: Building colormap SGN #%d (%s)\n", FuncName, i, CMn->Name);
00448
00449 for ( j = 0; j < i; ++j) {
00450 if (!INIT_ovin_sgn[i][j]) {
00451 if (LocalHead_Detail) {
00452 fprintf (SUMA_STDERR,"\t[i%d] NoColor\t%f\n",
00453 INIT_ovin_sgn[i][j],
00454 INIT_pval_sgn[i][j]);
00455 }
00456 CMn->M[i - j - 1][0] = CMn->M[i - j - 1][1] = CMn->M[i - j - 1][2] = -1.0;
00457 } else {
00458 if (LocalHead_Detail) {
00459 fprintf (SUMA_STDERR,"\t[i%d] %s\t%f\n",
00460 INIT_ovin_sgn[i][j],
00461 INIT_def_labovr[INIT_ovin_sgn[i][j]-1], INIT_pval_sgn[i][j]);
00462 }
00463 icol = SUMA_Find_Color (INIT_def_labovr[INIT_ovin_sgn[i][j]-1], Cv, N_cols);
00464 if (icol < 0) {
00465 fprintf (SUMA_STDERR,"Error%s: Failed to find color %s\nUsing no-color in its place",
00466 FuncName, INIT_def_labovr[INIT_ovin_sgn[i][j]-1]);
00467 CMn->M[i - j - 1][0] = CMn->M[i - j - 1][1] = CMn->M[i - j - 1][2] = -1.0;
00468 } else {
00469 CMn->M[i - j - 1][0] = Cv[icol].r;
00470 CMn->M[i - j - 1][1] = Cv[icol].g;
00471 CMn->M[i - j - 1][2] = Cv[icol].b;
00472 }
00473 }
00474 CMn->frac[i - j - 1] = INIT_pval_sgn[i][j];
00475 }
00476
00477
00478 CMv = SUMA_Add_ColorMap (CMn, CMv, &N_maps);
00479 if (!CMv) {
00480 SUMA_SL_Crit("Failed in SUMA_Add_ColorMap");
00481 SUMA_RETURN(NULL);
00482 }
00483 }
00484
00485
00486
00487
00488
00489
00490 SAC = (SUMA_AFNI_COLORS *) SUMA_malloc(sizeof(SUMA_AFNI_COLORS));
00491 SAC->CMv = CMv;
00492 SAC->N_maps = N_maps;
00493 SAC->Cv = Cv;
00494 SAC->N_cols = N_cols;
00495
00496
00497
00498
00499 SUMA_LH("Calling Process setup");
00500 homeenv = getenv("HOME");
00501
00502 if (!homeenv) sumarc = SUMA_copy_string(".afnirc");
00503 else sumarc = SUMA_append_string (homeenv, "/.afnirc");
00504 if (stat(sumarc, &stbuf) != -1) {
00505 if (LocalHead) fprintf (SUMA_STDERR,"%s: Loading %s ...\n", FuncName, sumarc);
00506 if (SUMA_AFNI_Extract_Colors ( sumarc, SAC ) < 0) {
00507 fprintf(SUMA_STDERR,"Error %s: Failed scanning .afnirc for colors and colormaps.\nProceeding ...\n", FuncName);
00508 }
00509 } else {
00510 if (LocalHead) fprintf (SUMA_STDERR,"%s: No rc files found.\n", FuncName);
00511 }
00512 if (sumarc) SUMA_free(sumarc);
00513
00514
00515 if (LocalHead_Detail) {
00516 SUMA_Show_ColorVec (SAC->Cv, SAC->N_cols, NULL);
00517 }
00518
00519 if (LocalHead_Detail) {
00520 SUMA_Show_ColorMapVec (SAC->CMv, SAC->N_maps, NULL, 1);
00521 }
00522
00523 SUMA_LH("Returning");
00524
00525 SUMA_RETURN(SAC);
00526 }
00527
00528
00529
00530
00531 SUMA_AFNI_COLORS *SUMA_Build_Color_maps(void)
00532 {
00533 static char FuncName[]={"SUMA_Build_Color_maps"};
00534 SUMA_RGB_NAME *Cv = NULL;
00535 int i;
00536 SUMA_COLOR_MAP **CMv=NULL;
00537 SUMA_COLOR_MAP *CM=NULL;
00538 SUMA_AFNI_COLORS *SAC=NULL;
00539
00540 SUMA_ENTRY;
00541
00542 SAC = SUMA_Get_AFNI_Default_Color_Maps();
00543
00544
00545
00546 for (i=SUMA_CMAP_UNDEFINED+1; i<SUMA_CMAP_N_MAPS; ++i) {
00547 CM = SUMA_GetStandardMap (i);
00548 if (!CM) {
00549 SUMA_SL_Crit("Failed to create standard maps");
00550 SUMA_RETURN(NULL);
00551 }
00552 SAC->CMv = SUMA_Add_ColorMap (CM, SAC->CMv, &(SAC->N_maps));
00553 if (!SAC->CMv) {
00554 SUMA_SL_Crit("Failed in SUMA_Add_ColorMap");
00555 SUMA_RETURN(NULL);
00556 }
00557 }
00558
00559 SUMA_RETURN(SAC);
00560 }
00561
00562
00563
00564
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584 SUMA_RGB_NAME * SUMA_Add_Color (char *Name, float r, float g, float b, float a, SUMA_RGB_NAME *oCv, int *N_cols)
00585 {
00586 static char FuncName[]={"SUMA_Add_Color"};
00587 SUMA_RGB_NAME *NewCv = NULL;
00588 int iadd;
00589 SUMA_Boolean LocalHead = NOPE;
00590
00591 SUMA_ENTRY;
00592
00593 if (!(r == -1.0 && g == -1.0 && b == -1.0)) {
00594 if ( r < 0 || r > 1 ||
00595 g < 0 || g > 1 ||
00596 b < 0 || b > 1 ||
00597 a < 0 || a > 1 ) {
00598 SUMA_S_Err("Bad r, g, b and/or a values.\nMust be between 0 and 1.Nothing done.");
00599 SUMA_RETURN(oCv);
00600 }
00601 }else {
00602 SUMA_LH("No color");
00603 }
00604
00605 if (strlen(Name) > SUMA_MAX_COLOR_NAME -1 ) {
00606 SUMA_S_Err("Too long a color name\n(> SUMA_MAX_COLOR_NAME)\nNothing done.");
00607 SUMA_RETURN(oCv);
00608 }
00609
00610 if (!oCv) {
00611 SUMA_LH("New color vector, allocating");
00612 NewCv = (SUMA_RGB_NAME *) SUMA_calloc(1, sizeof(SUMA_RGB_NAME));
00613 *N_cols = 1;
00614 NewCv[*N_cols-1].r = r;
00615 NewCv[*N_cols-1].g = g;
00616 NewCv[*N_cols-1].b = b;
00617 NewCv[*N_cols-1].a = a;
00618 sprintf(NewCv[*N_cols-1].Name, "%s", Name);
00619 SUMA_RETURN(NewCv);
00620 }
00621
00622
00623 iadd = SUMA_Find_Color (Name, oCv, *N_cols);
00624
00625 if (iadd >= 0) {
00626 SUMA_LH("Replacing old color");
00627 NewCv = oCv;
00628 NewCv[iadd].r = r;
00629 NewCv[iadd].g = g;
00630 NewCv[iadd].b = b;
00631 NewCv[iadd].a = a;
00632 SUMA_RETURN(oCv);
00633 }
00634
00635
00636 SUMA_LH("Adding new color");
00637 *N_cols += 1;
00638 NewCv = (SUMA_RGB_NAME *) SUMA_realloc(oCv, *N_cols * sizeof(SUMA_RGB_NAME));
00639 NewCv[*N_cols-1].r = r;
00640 NewCv[*N_cols-1].g = g;
00641 NewCv[*N_cols-1].b = b;
00642 NewCv[*N_cols-1].a = a;
00643 sprintf(NewCv[*N_cols-1].Name, "%s", Name);
00644
00645 SUMA_RETURN(NewCv);
00646 }
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665 SUMA_COLOR_MAP ** SUMA_Add_ColorMap (SUMA_COLOR_MAP *CM, SUMA_COLOR_MAP **OldCMv, int *N_maps)
00666 {
00667 static char FuncName[]={"SUMA_Add_ColorMap"};
00668 SUMA_COLOR_MAP ** NewCMv = NULL;
00669 int iadd;
00670 SUMA_Boolean LocalHead = NOPE;
00671
00672 SUMA_ENTRY;
00673
00674 if (!CM) {
00675 SUMA_S_Warn("Null CM, nothing to do");
00676 SUMA_RETURN(OldCMv);
00677 }
00678 if (!OldCMv) {
00679 SUMA_LH("New color vector, allocating");
00680 NewCMv = (SUMA_COLOR_MAP **) SUMA_calloc(1, sizeof(SUMA_COLOR_MAP *));
00681 *N_maps = 1;
00682 NewCMv[0] = CM;
00683 SUMA_RETURN(NewCMv);
00684 }
00685
00686
00687 iadd = SUMA_Find_ColorMap (CM->Name, OldCMv, *N_maps, CM->Sgn);
00688 if (iadd >= 0) {
00689 SUMA_LH("Replacing old colormap");
00690 SUMA_Free_ColorMap (OldCMv[iadd]);
00691 OldCMv[iadd] = CM;
00692 SUMA_RETURN(OldCMv);
00693 }
00694
00695
00696 SUMA_LH("Adding new color map");
00697 *N_maps += 1;
00698 NewCMv = (SUMA_COLOR_MAP **) SUMA_realloc(OldCMv, *N_maps * sizeof(SUMA_COLOR_MAP *));
00699 NewCMv[*N_maps - 1] = CM;
00700
00701 SUMA_RETURN(NewCMv);
00702 }
00703
00704
00705
00706
00707
00708 SUMA_AFNI_COLORS *SUMA_DestroyAfniColors (SUMA_AFNI_COLORS *SAC)
00709 {
00710 static char FuncName[]={"SUMA_DestroyAfniColors"};
00711 int i;
00712
00713 if (!SAC) SUMA_RETURN(NULL);
00714
00715
00716 for (i=0; i < SAC->N_maps; ++i) {
00717 if (SAC->CMv[i]) SUMA_Free_ColorMap(SAC->CMv[i]);
00718 }
00719 SUMA_free(SAC->CMv);
00720 SAC->N_maps = -1;
00721
00722
00723 SUMA_free(SAC->Cv);
00724 SAC->N_cols = -1;
00725
00726
00727 SUMA_free(SAC);
00728
00729 SUMA_RETURN(NULL);
00730 }
00731
00732
00733
00734
00735
00736 char *SUMA_ColorVec_Info (SUMA_RGB_NAME *Cv, int N_cols)
00737 {
00738 static char FuncName[]={"SUMA_ColorVec_Info"};
00739 int i;
00740 char stmp[100], *s = NULL;
00741 SUMA_STRING *SS = NULL;
00742 SUMA_Boolean LocalHead = NOPE;
00743
00744 SUMA_ENTRY;
00745
00746 SS = SUMA_StringAppend (NULL, NULL);
00747
00748 if (Cv) {
00749 for (i=0; i < N_cols; ++i) {
00750 if (Cv[i].r == -1) {
00751 sprintf (stmp, "%d/%d: color(%d) No Color(%s): [%f %f %f %f]\n",
00752 i+1, N_cols, i, Cv[i].Name, Cv[i].r, Cv[i].g, Cv[i].b, Cv[i].a);
00753 SS = SUMA_StringAppend (SS, stmp);
00754 } else {
00755 sprintf (stmp, "%d/%d: color(%d) %s: [%f %f %f %f]\n",
00756 i+1, N_cols, i, Cv[i].Name, Cv[i].r, Cv[i].g, Cv[i].b, Cv[i].a);
00757 SS = SUMA_StringAppend (SS, stmp);
00758 }
00759 }
00760 } else {
00761 sprintf (stmp, "NULL Cv.\n");
00762 SS = SUMA_StringAppend (SS, stmp);
00763 }
00764
00765
00766 SS = SUMA_StringAppend (SS, NULL);
00767
00768 s = SS->s;
00769 SUMA_free(SS);
00770
00771 SUMA_RETURN(s);
00772 }
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786 char *SUMA_ColorMapVec_Info (SUMA_COLOR_MAP **CMv, int N_maps, int detail)
00787 {
00788 static char FuncName[]={"SUMA_ColorMapVec_Info"};
00789 int i, j, jmax;
00790 char stmp[256], *s = NULL;
00791 SUMA_STRING *SS = NULL;
00792 SUMA_Boolean LocalHead = NOPE;
00793
00794 SUMA_ENTRY;
00795
00796 SUMA_LH("Entered");
00797 SS = SUMA_StringAppend (NULL, NULL);
00798
00799 if (CMv) {
00800 for (i=0; i < N_maps; ++i) {
00801 if (!CMv[i]) {
00802 sprintf (stmp, "%d/%d: cmap(%d) NULL\n", i+1, N_maps, i);
00803 SS = SUMA_StringAppend (SS, stmp);
00804 } else {
00805 switch (CMv[i]->Sgn) {
00806 case 0:
00807 sprintf (stmp, "%d/%d: cmap(%d) %s(.), %d cols.", i+1, N_maps, i, CMv[i]->Name, CMv[i]->N_Col);
00808 break;
00809 case 1:
00810 sprintf (stmp, "%d/%d: cmap(%d) %s(+), %d cols.", i+1, N_maps, i, CMv[i]->Name, CMv[i]->N_Col);
00811 break;
00812 case -1:
00813 sprintf (stmp, "%d/%d: cmap(%d) %s(-), %d cols.", i+1, N_maps, i, CMv[i]->Name, CMv[i]->N_Col);
00814 break;
00815 default:
00816 sprintf (stmp, "%d/%d: cmap(%d) %s(?), %d cols.\n\tSgn field of colormap is not acceptable (%d)\n",
00817 i+1, N_maps, i, CMv[i]->Name, CMv[i]->N_Col, CMv[i]->Sgn);
00818 break;
00819 }
00820 SS = SUMA_StringAppend (SS, stmp);
00821 if (CMv[i]->frac) {
00822 SS = SUMA_StringAppend (SS, " Possibly non-linear\n");
00823 } else {
00824 SS = SUMA_StringAppend (SS, " Linear\n");
00825 }
00826 switch (detail) {
00827 case 0:
00828 jmax = 0;
00829 break;
00830 case 1:
00831 if (CMv[i]->N_Col < 5) jmax = CMv[i]->N_Col;
00832 else jmax = 5;
00833 break;
00834 case 2:
00835 jmax = CMv[i]->N_Col;
00836 break;
00837 default:
00838 SUMA_SL_Err("Bad detail value\nUsing detail = 2");
00839 jmax = CMv[i]->N_Col;
00840 break;
00841 }
00842
00843 if (jmax) {
00844 for (j=jmax-1; j >= 0; --j) {
00845 if (CMv[i]->frac) {
00846 if (j == jmax -1) {
00847 sprintf (stmp, "rank (i)[R \tG \tB \t\tf]\n");
00848 SS = SUMA_StringAppend (SS,stmp);
00849 }
00850 sprintf (stmp, "%03d:\t[% .3f\t% .3f\t% .3f\t\t% .3f]\n",
00851 j, CMv[i]->M[j][0], CMv[i]->M[j][1], CMv[i]->M[j][2], CMv[i]->frac[j]);
00852 } else {
00853 if (j == jmax - 1) {
00854 sprintf (stmp, "rank (i):[R \tG \tB ]\n");
00855 SS = SUMA_StringAppend (SS,stmp);
00856 }
00857 sprintf (stmp, "%03d:\t[% .3f\t% .3f\t% .3f]\n",
00858 j, CMv[i]->M[j][0], CMv[i]->M[j][1], CMv[i]->M[j][2]);
00859 }
00860 SS = SUMA_StringAppend (SS,stmp);
00861 }
00862 if (jmax < CMv[i]->N_Col - 1) {
00863 if (CMv[i]->frac) SS = SUMA_StringAppend (SS,"..:\t [.....\t....\t....\t\t....]\n");
00864 else SS = SUMA_StringAppend (SS,"..:\t [.....\t....\t....]\n");
00865 }
00866 if (jmax < CMv[i]->N_Col) {
00867 j = CMv[i]->N_Col - 1;
00868 if (CMv[i]->frac) {
00869 sprintf (stmp, "%03d:\t [% .3f\t% .3f\t% .3f\t\t% .3f]\n",
00870 j, CMv[i]->M[j][0], CMv[i]->M[j][1], CMv[i]->M[j][2], CMv[i]->frac[j]);
00871 } else {
00872 sprintf (stmp, "%03d:\t [% .3f\t% .3f\t% .3f]\n",
00873 j, CMv[i]->M[j][0], CMv[i]->M[j][1], CMv[i]->M[j][2]);
00874 }
00875 SS = SUMA_StringAppend (SS,stmp);
00876 }
00877 }
00878 }
00879 }
00880 } else {
00881 sprintf (stmp, "NULL CMv.\n");
00882 SS = SUMA_StringAppend (SS, stmp);
00883 }
00884
00885
00886 SS = SUMA_StringAppend (SS, NULL);
00887
00888 s = SS->s;
00889 SUMA_free(SS);
00890
00891 SUMA_LH("Left");
00892
00893 SUMA_RETURN(s);
00894 }
00895
00896
00897
00898
00899
00900 void SUMA_Show_ColorVec (SUMA_RGB_NAME *CMv, int N_maps, FILE *Out)
00901 {
00902 static char FuncName[]={"SUMA_Show_ColorVec"};
00903 char *s;
00904
00905 SUMA_ENTRY;
00906
00907 if (Out == NULL) Out = stdout;
00908
00909 s = SUMA_ColorVec_Info(CMv, N_maps);
00910
00911 if (s) {
00912 fprintf (Out, "%s", s);
00913 SUMA_free(s);
00914 }else {
00915 fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_ColorVec_Info.\n", FuncName);
00916 }
00917
00918 SUMA_RETURNe;
00919 }
00920
00921
00922
00923
00924
00925 void SUMA_Show_ColorMapVec (SUMA_COLOR_MAP **CMv, int N_maps, FILE *Out, int detail)
00926 {
00927 static char FuncName[]={"SUMA_Show_ColorMapVec"};
00928 char *s;
00929 SUMA_Boolean LocalHead = NOPE;
00930
00931 SUMA_ENTRY;
00932
00933
00934 if (Out == NULL) Out = stdout;
00935
00936 s = SUMA_ColorMapVec_Info(CMv, N_maps, detail);
00937
00938 if (s) {
00939 fprintf (Out, "%s", s);
00940 SUMA_free(s);
00941 }else {
00942 fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_ColorMapVec_Info.\n", FuncName);
00943 }
00944
00945
00946 SUMA_RETURNe;
00947 }
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957 int SUMA_Find_Color ( char *Name, SUMA_RGB_NAME *Cv, int N_cols)
00958 {
00959 static char FuncName[]={"SUMA_Find_Color"};
00960 int icol = -1, i;
00961 SUMA_Boolean LocalHead = NOPE;
00962
00963 SUMA_ENTRY;
00964
00965 if (!Cv) {
00966 SUMA_S_Warn("Nothing to do. NULL Cv");
00967 SUMA_RETURN(icol);
00968 }
00969
00970 for (i=0; i < N_cols; ++i) {
00971 if (strcmp(Cv[i].Name, Name) == 0) {
00972 SUMA_LH("Found Color");
00973 icol = i;
00974 SUMA_RETURN(icol);
00975 }
00976 }
00977
00978 SUMA_LH("Failed to find color");
00979 SUMA_RETURN(icol);
00980 }
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993 int SUMA_Find_ColorMap ( char *Name, SUMA_COLOR_MAP **CMv, int N_maps, int sgn)
00994 {
00995 static char FuncName[]={"SUMA_Find_ColorMap"};
00996 int imap = -1, i;
00997 SUMA_Boolean LocalHead = NOPE;
00998
00999 SUMA_ENTRY;
01000
01001 if (!CMv) {
01002 SUMA_S_Warn("Nothing to do. NULL CMv");
01003 SUMA_RETURN(imap);
01004 }
01005
01006
01007 for (i=0; i < N_maps; ++i) {
01008 if (CMv[i]) {
01009 if (sgn != -2) {
01010 if (strcmp(CMv[i]->Name, Name) == 0 && CMv[i]->Sgn == sgn) {
01011 SUMA_LH("Found Map");
01012 imap = i;
01013 SUMA_RETURN(imap);
01014 }
01015 } else {
01016
01017 if (strcmp(CMv[i]->Name, Name) == 0 ) {
01018 SUMA_LH("Found Map");
01019 imap = i;
01020 SUMA_RETURN(imap);
01021 }
01022 }
01023 }
01024 }
01025
01026 SUMA_LH("Failed to find map");
01027 SUMA_RETURN(imap);
01028 }
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045 SUMA_COLOR_MAP *SUMA_Read_Color_Map_1D (char *Name)
01046 {
01047 static char FuncName[]={"SUMA_Read_Color_Map_1D"};
01048 MRI_IMAGE *im = NULL;
01049 float *far=NULL;
01050 float ColSum;
01051 int i=0;
01052 SUMA_COLOR_MAP* SM = NULL;
01053 SUMA_Boolean LocalHead = NOPE;
01054
01055 SUMA_ENTRY;
01056
01057 if (!Name) {
01058 SUMA_S_Err("NULL file name");
01059 SUMA_RETURN(SM);
01060 }
01061
01062
01063 im = mri_read_1D (Name);
01064 if (!im) {
01065 SUMA_S_Err("Failed to read file");
01066 SUMA_RETURN(NULL);
01067 }
01068
01069
01070 if (im->ny != 3 && im->ny != 4) {
01071 SUMA_S_Err("File must contain 3 or 4 columns only");
01072 SUMA_RETURN(NULL);
01073
01074 }
01075
01076
01077
01078 SM = (SUMA_COLOR_MAP*) SUMA_malloc(sizeof(SUMA_COLOR_MAP));
01079 SM->SO = NULL;
01080 SM->cname = NULL;
01081 SM->N_Col = im->nx;
01082 SM->Name = (char *)SUMA_malloc(sizeof(char)*(strlen(Name)+1));
01083 sprintf(SM->Name, "%s", Name);
01084 if (im->ny == 4) {
01085 SM->frac = (float*) SUMA_calloc(im->nx, sizeof(float));
01086 } else {
01087 SM->frac = NULL;
01088 }
01089
01090 SM->M = (float**)SUMA_allocate2D (SM->N_Col, 3, sizeof(float));
01091
01092
01093 far = MRI_FLOAT_PTR(im);
01094
01095 ColSum = 0;
01096 if (im->ny == 4) {
01097 SM->Sgn = 1;
01098 for (i=0; i < im->nx; ++i) {
01099 SM->M[SM->N_Col - i - 1][0] = far[i]; ColSum += far[i];
01100 SM->M[SM->N_Col - i - 1][1] = far[i+im->nx]; ColSum += far[i+im->nx];
01101 SM->M[SM->N_Col - i - 1][2] = far[i+2*im->nx]; ColSum += far[i+2*im->nx];
01102 SM->frac[SM->N_Col - i - 1] = far[i+3*im->nx];
01103 if (SM->frac[SM->N_Col - i - 1] < 0.0) SM->Sgn = -1;
01104 }
01105 } else {
01106 SM->Sgn = 0;
01107 for (i=0; i < im->nx; ++i) {
01108 SM->M[SM->N_Col - i - 1][0] = far[i]; ColSum += far[i];
01109 SM->M[SM->N_Col - i - 1][1] = far[i+im->nx]; ColSum += far[i+im->nx];
01110 SM->M[SM->N_Col - i - 1][2] = far[i+2*im->nx]; ColSum += far[i+2*im->nx];
01111 }
01112 }
01113
01114 ColSum = ColSum / (3.0 * SM->N_Col);
01115 if (ColSum > 1) {
01116
01117 for (i=0; i < SM->N_Col; ++i) {
01118 SM->M[i][0] /= 255.0; SM->M[i][1] /= 255.0; SM->M[i][2] /= 255.0;
01119 }
01120 }
01121
01122
01123 if (SM->frac && SM->N_Col > 1) {
01124 for (i=0; i < im->nx-1; ++i) {
01125 if (SM->frac[i] > SM->frac[i+1]) {
01126 SUMA_S_Err("Fractions must be specified in monotonic\n descending order from the top to the bottom of the column");
01127 SUMA_Free_ColorMap (SM); mri_free(im);
01128 SUMA_RETURN(NULL);
01129 }
01130 }
01131 }
01132
01133 mri_free(im); im = NULL;
01134
01135 if (LocalHead) {
01136 fprintf (SUMA_STDERR,"%s: Colormap read:\n", FuncName);
01137 if (SM->frac) {
01138 for (i=0; i < SM->N_Col; ++i) {
01139 fprintf (SUMA_STDOUT,"%f\t%f\t%f\t%f\n", SM->M[i][0], SM->M[i][1], SM->M[i][2], SM->frac[i]);
01140 }
01141 } else SUMA_disp_mat (SM->M, SM->N_Col, 3, 1);
01142 }
01143
01144
01145 SUMA_RETURN (SM);
01146 }
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159 SUMA_COLOR_MAP *SUMA_Linearize_Color_Map (SUMA_COLOR_MAP* SM, int N_lin)
01160 {
01161 static char FuncName[]={"SUMA_Linearize_Color_Map"};
01162 SUMA_COLOR_MAP* LSM = NULL;
01163 int ilin = 0, i = 0, ilin_stp = -1;
01164 SUMA_Boolean LocalHead = NOPE;
01165
01166 SUMA_ENTRY;
01167
01168 if (!SM) {
01169 SUMA_S_Err("NULL color map");
01170 SUMA_RETURN(LSM);
01171 }
01172
01173 if (!SM->frac) {
01174 SUMA_S_Err("NULL SM->frac!\nMap is linear");
01175 SUMA_RETURN(LSM);
01176 }
01177
01178 if (N_lin < 0) N_lin = 2048;
01179
01180 if (!N_lin) {
01181 SUMA_S_Err("N_lin = 0");
01182 SUMA_RETURN(LSM);
01183 }
01184
01185
01186 LSM = (SUMA_COLOR_MAP *)SUMA_malloc(sizeof(SUMA_COLOR_MAP));
01187 if (LSM == NULL) {
01188 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for LSM.\n", FuncName);
01189 SUMA_RETURN (NULL);
01190 }
01191 LSM->SO = NULL;
01192
01193 LSM->Name = (char *)SUMA_calloc(strlen(SM->Name)+10, sizeof(char));
01194 if (LSM->Name == NULL) {
01195 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for LSM->Name.\n", FuncName);
01196 SUMA_free(LSM);
01197 SUMA_RETURN (NULL);
01198 }
01199 sprintf(LSM->Name, "%s_lin",SM->Name);
01200 LSM->N_Col = N_lin;
01201 LSM->frac = NULL;
01202 LSM->cname = NULL;
01203 LSM->Sgn = SM->Sgn;
01204
01205 LSM->M = (float **)SUMA_allocate2D (LSM->N_Col, 3, sizeof(float));
01206 if (LSM->M == NULL) {
01207 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for LSM->M.\n", FuncName);
01208 SUMA_free(LSM->Name);
01209 SUMA_free(LSM);
01210 SUMA_RETURN (NULL);
01211 }
01212
01213 ilin = 0;
01214 for (i=0; i < SM->N_Col; ++i) {
01215 if (LSM->Sgn >= 0) {
01216 ilin_stp = (int)(ceil((double)SM->frac[i] * (double)LSM->N_Col)) - 1;
01217 } else {
01218 ilin_stp = (int)(ceil( (1.0 + (double)SM->frac[i]) * (double)LSM->N_Col/2 ) ) - 1;
01219 }
01220 while (ilin < ilin_stp) {
01221 LSM->M[ilin][0] = SM->M[i][0];
01222 LSM->M[ilin][1] = SM->M[i][1];
01223 LSM->M[ilin][2] = SM->M[i][2];
01224 ++ilin;
01225 }
01226 }
01227
01228
01229 LSM->M[LSM->N_Col-1][0] = SM->M[SM->N_Col-1][0];
01230 LSM->M[LSM->N_Col-1][1] = SM->M[SM->N_Col-1][1];
01231 LSM->M[LSM->N_Col-1][2] = SM->M[SM->N_Col-1][2];
01232
01233 if (LocalHead) {
01234 for (i=0; i < LSM->N_Col; ++i) {
01235 fprintf (SUMA_STDOUT,"%d:\t%f\t%f\t%f\n", i, LSM->M[i][0], LSM->M[i][1], LSM->M[i][2]);
01236 }
01237 fprintf (SUMA_STDOUT,"%s: ilin_stp = %d\n", FuncName, ilin_stp);
01238 }
01239
01240 SUMA_RETURN(LSM);
01241 }
01242
01243
01244
01245
01246
01247
01248
01249 int r_sprintf_long_to_hex
01250 (
01251 char * dest,
01252 unsigned long lsrc,
01253 int bytes,
01254 int pad
01255 )
01256 {
01257 static char hexstring[] = "0123456789ABCDEF";
01258
01259 unsigned char ub;
01260 char * cp = dest;
01261 int posn, size, ret;
01262
01263 if ( (bytes <= 0) || (bytes > 4) )
01264 {
01265 *cp = '\0';
01266 return 0;
01267 }
01268
01269 size = r_ulong_size( lsrc );
01270
01271 if ( (size < bytes) && !pad )
01272 ret = size;
01273 else
01274 ret = bytes;
01275
01276 for ( posn = ret-1; posn >= 0; posn-- )
01277 {
01278
01279 ub = ( lsrc >> (posn << 3) ) & 0xff;
01280 *cp++ = hexstring[(ub>>4) & 0xf];
01281 *cp++ = hexstring[ ub & 0xf];
01282 }
01283
01284 *cp = '\0';
01285
01286 return ret;
01287 }
01288
01289
01290 int r_ulong_size ( unsigned long l )
01291 {
01292 if ( l & 0xff000000 )
01293 return 4;
01294
01295 if ( l & 0xff0000 )
01296 return 3;
01297
01298 if ( l & 0xff00 )
01299 return 2;
01300
01301 return 1;
01302 }
01303
01304 #ifdef SUMA_MakeColorMap_STAND_ALONE
01305 void SUMA_MakeColorMap_usage ()
01306 {
01307 static char FuncName[]={"SUMA_MakeColorMap_usage"};
01308 char * s = NULL;
01309 s = SUMA_help_basics();
01310 fprintf (SUMA_STDOUT, "\n"
01311 "Usage1: \n"
01312 "MakeColorMap <-fn Fiducials_Ncol> [-pos] [-ah prefix] [-h/-help]\n"
01313 " Creates a colormap of N colors that contains the fiducial colors.\n"
01314 " -fn Fiducials_Ncol: Fiducial colors and their indices in the color\n"
01315 " map are listed in file Fiducials_Ncol.\n"
01316 " Each row contains 4 tab delimited values:\n"
01317 " R G B i\n"
01318 " R G B values are between 0 and 1 and represent the \n"
01319 " i-th color in the colormap. i should be between 0 and\n"
01320 " N-1, N being the total number of colors in the colormap.\n"
01321 "\n"
01322 "Usage2: \n"
01323 "MakeColorMap <-f Fiducials> <-nc N> [-sl] [-ah prefix] [-h/-help]\n"
01324 " Creates a colormap of N colors that contains the fiducial colors.\n"
01325 " -f Fiducials: Fiducial colors are listed in an ascii file Fiducials. \n"
01326 " Each row contains 3 tab delimited R G B values between 0 and 1.\n"
01327 " -nc N: Total number of colors in the color map.\n"
01328 " -sl: (optional, default is NO) if used, the last color in the Fiducial \n"
01329 " list is omitted. This is useful in creating cyclical color maps.\n"
01330 "\n"
01331 "Usage3: \n"
01332 "MakeColorMap <-std MapName>\n"
01333 " Returns one of SUMA's standard colormaps. Choose from:\n"
01334 " rgybr20, ngray20, gray20, bw20, bgyr19, \n"
01335 " matlab_default_byr64, roi128, roi256, roi64\n"
01336 "\n"
01337 "Common options to all usages:\n"
01338 " -ah prefix: (optional, Afni Hex format.\n"
01339 " default is RGB values in decimal form)\n"
01340 " use this option if you want a color map formatted to fit \n"
01341 " in AFNI's .afnirc file. The colormap is written out as \n"
01342 " prefix_01 = #xxxxxxx \n prefix_02 = #xxxxxxx\n etc...\n"
01343 " -h or -help: displays this help message.\n"
01344 "\n"
01345 ""
01346 "Example Usage 1: Creating a colormap of 20 colors that goes from \n"
01347 "Red to Green to Blue to Yellow to Red.\n"
01348 "\n"
01349 " The file FidCol_Nind contains the following:\n"
01350 " 1 0 0 0\n 0 1 0 5\n 0 0 1 10\n 1 1 0 15\n 1 0 0 19\n"
01351 "\n"
01352 " The following command will generate the RGB colormap in decimal form:\n"
01353 " MakeColorMap -fn FidCol_Nind \n"
01354 "\n"
01355 " The following command will generate the colormap and write it as \n"
01356 " an AFNI color palette file:\n"
01357 " MakeColorMap -fn FidCol_Nind -ah TestPalette > TestPalette.pal\n"
01358 "\n"
01359 "Example Usage 2: Creating a cyclical version of the colormap in usage 1:\n"
01360 "\n"
01361 " The file FidCol contains the following:\n"
01362 " 1 0 0\n 0 1 0\n 0 0 1\n 1 1 0\n 1 0 0\n"
01363 "\n"
01364 " The following command will generate the RGB colormap in decimal form:\n"
01365 " MakeColorMap -f FidCol -sl -nc 20 \n"
01366 "\n"
01367 "Example Usage 3: MakeColorMap -std ngray20 \n"
01368 "\n"
01369 "To read in a new colormap into AFNI, either paste the contents of \n"
01370 "TestPalette.pal in your .afnirc file or read the .pal file using \n"
01371 "AFNI as follows:\n"
01372 "1- run afni\n2- Define Function --> right click on Inten (over colorbar) \n"
01373 " --> Read in palette (choose TestPalette.pal)\n"
01374 "3- set the #colors chooser (below colorbar) to 20 (the number of colors in \n"
01375 " TestPalette.pal).\n"
01376 "%s",s);
01377 SUMA_free(s); s = NULL;
01378 s = SUMA_New_Additions(0, 1); printf("%s\n", s);SUMA_free(s); s = NULL;
01379 fprintf (SUMA_STDOUT, " Ziad S. Saad & Rick R. Reynolds SSCC/NIMH/NIH ziad@nih.gov Tue Apr 23 14:14:48 EDT 2002\n\n");
01380
01381 }
01382
01383 int main (int argc,char *argv[])
01384 {
01385 static char FuncName[]={"MakeColorMap"};
01386 char *FidName = NULL, *Prfx = NULL, h[9], *StdType=NULL;
01387 int Ncols = 0, N_Fid = 0, kar, i, ifact, *Nind = NULL;
01388 float **Fid=NULL, **M=NULL;
01389 MRI_IMAGE *im = NULL;
01390 float *far=NULL;
01391 SUMA_Boolean brk, SkipLast, AfniHex, PosMap,
01392 Usage1, Usage2, Usage3, LocalHead = NOPE;
01393 SUMA_COLOR_MAP *SM=NULL;
01394
01395 SUMA_mainENTRY;
01396
01397 SUMA_STANDALONE_INIT;
01398
01399
01400 if (argc < 2) {
01401 SUMA_MakeColorMap_usage();
01402 exit (1);
01403 }
01404
01405 kar = 1;
01406 brk = NOPE;
01407 SkipLast = NOPE;
01408 AfniHex = NOPE;
01409 PosMap = NOPE;
01410 Usage1 = NOPE;
01411 Usage2 = NOPE;
01412 Usage3 = NOPE;
01413 while (kar < argc) {
01414 if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) {
01415 SUMA_MakeColorMap_usage();
01416 exit (1);
01417 }
01418
01419 SUMA_SKIP_COMMON_OPTIONS(brk, kar);
01420
01421 if (!brk && (strcmp(argv[kar], "-v") == 0))
01422 {
01423 LocalHead = NOPE;
01424 brk = YUP;
01425 }
01426 if (!brk && (strcmp(argv[kar], "-f") == 0))
01427 {
01428 kar ++;
01429 if (kar >= argc) {
01430 fprintf (SUMA_STDERR, "need argument after -f ");
01431 exit (1);
01432 }
01433 FidName = argv[kar];
01434 Usage1 = YUP;
01435 brk = YUP;
01436 }
01437
01438 if (!brk && (strcmp(argv[kar], "-fn") == 0))
01439 {
01440 kar ++;
01441 if (kar >= argc) {
01442 fprintf (SUMA_STDERR, "need argument after -fn ");
01443 exit (1);
01444 }
01445 FidName = argv[kar];
01446 Usage2 = YUP;
01447 brk = YUP;
01448 }
01449
01450 if (!brk && (strcmp(argv[kar], "-nc") == 0))
01451 {
01452 kar ++;
01453 if (kar >= argc) {
01454 fprintf (SUMA_STDERR, "need argument after -nc ");
01455 exit (1);
01456 }
01457 Ncols = atoi(argv[kar]);
01458 Usage1 = YUP;
01459 brk = YUP;
01460 }
01461
01462 if (!brk && (strcmp(argv[kar], "-ah") == 0))
01463 {
01464 kar ++;
01465 if (kar >= argc) {
01466 fprintf (SUMA_STDERR, "need argument after -ah ");
01467 exit (1);
01468 }
01469 Prfx = argv[kar];
01470 AfniHex = YUP;
01471 brk = YUP;
01472 }
01473
01474 if (!brk && (strcmp(argv[kar], "-std") == 0))
01475 {
01476 kar ++;
01477 if (kar >= argc) {
01478 fprintf (SUMA_STDERR, "need argument after -std ");
01479 exit (1);
01480 }
01481 StdType = argv[kar];
01482 Usage3 = YUP;
01483 brk = YUP;
01484 }
01485
01486 if (!brk && (strcmp(argv[kar], "-sl") == 0))
01487 {
01488 SkipLast = YUP;
01489 brk = YUP;
01490 }
01491
01492 if (!brk && (strcmp(argv[kar], "-pos") == 0))
01493 {
01494
01495 PosMap = YUP;
01496
01497 brk = YUP;
01498 }
01499
01500 if (!brk) {
01501 fprintf (SUMA_STDERR,"Error %s: Option %s not understood. Try -help for usage\n", FuncName, argv[kar]);
01502 exit (1);
01503 } else {
01504 brk = NOPE;
01505 kar ++;
01506 }
01507
01508 }
01509
01510
01511 if ( (Usage1 && Usage2) || (Usage1 && Usage3) || (Usage2 && Usage3)) {
01512 fprintf (SUMA_STDERR,"Error %s: Mixing options from multiple usage modes.\n", FuncName);
01513 exit(1);
01514 }
01515
01516 if (!Usage1 && !Usage2 && !Usage3) {
01517 fprintf (SUMA_STDERR,"Error %s: One of these options must be used:\n-f -fn or -std.\n", FuncName);
01518 exit(1);
01519 }
01520
01521 if (Usage1 || Usage2) {
01522 if (!SUMA_filexists (FidName)) {
01523 fprintf (SUMA_STDERR,"Error %s: File %s could not be found.\n", FuncName, FidName);
01524 exit(1);
01525 }
01526
01527
01528 im = mri_read_1D (FidName);
01529 if (!im) {
01530 SUMA_S_Err("Failed to read file");
01531 exit(1);
01532 }
01533
01534 far = MRI_FLOAT_PTR(im);
01535 N_Fid = im->nx * im->ny;
01536 }
01537
01538 if (PosMap) {
01539 fprintf (SUMA_STDERR,"\nWarning %s: -pos option is obsolete.\n", FuncName);
01540 }
01541
01542
01543
01544 if (Usage1) {
01545 if (N_Fid % 3) {
01546 fprintf (SUMA_STDERR,"Error %s: Not all rows in %s appear to have RGB triplets.\n", FuncName, FidName);
01547 exit (1);
01548 }
01549
01550 Fid = (float **) SUMA_allocate2D (N_Fid / 3, 3, sizeof(float));
01551 if (Fid == NULL) {
01552 fprintf (SUMA_STDERR,"Error %s: Could not allocate for Fid.\n", FuncName);
01553 exit(1);
01554 }
01555
01556 for (i=0; i < im->nx; ++i) {
01557 Fid[i][0] = far[i];
01558 Fid[i][1] = far[i+im->nx];
01559 Fid[i][2] = far[i+2*im->nx];
01560 }
01561
01562 mri_free(im); im = NULL;
01563
01564 SM = SUMA_MakeColorMap (Fid, N_Fid/3, Ncols, SkipLast, FuncName);
01565 if (SM == NULL) {
01566 fprintf (SUMA_STDERR,"Error %s: Error in SUMA_MakeColorMap.\n", FuncName);
01567 exit(1);
01568 }
01569 }
01570 if (Usage2) {
01571 if (N_Fid % 4) {
01572 fprintf (SUMA_STDERR,"Error %s: Not all rows in %s appear to have RGB N quadruplets.\n", FuncName, FidName);
01573 exit (1);
01574 }
01575
01576 Fid = (float **) SUMA_allocate2D (N_Fid / 4, 3, sizeof(float));
01577 Nind = (int *) SUMA_calloc (N_Fid/4, sizeof(int));
01578 if (Fid == NULL || !Nind) {
01579 fprintf (SUMA_STDERR,"Error %s: Could not allocate for Fid or Nind.\n", FuncName);
01580 exit(1);
01581 }
01582
01583 for (i=0; i < im->nx; ++i) {
01584 Fid[i][0] = far[i];
01585 Fid[i][1] = far[i+im->nx];
01586 Fid[i][2] = far[i+2*im->nx];
01587 Nind[i] = (int)far[i+3*im->nx];
01588 }
01589
01590 mri_free(im); im = NULL;
01591
01592
01593 SM = SUMA_MakeColorMap_v2 (Fid, N_Fid/4, Nind, SkipLast, FuncName);
01594 if (SM == NULL) {
01595 fprintf (SUMA_STDERR,"Error %s: Error in SUMA_MakeColorMap.\n", FuncName);
01596 exit(1);
01597 }
01598 Ncols = SM->N_Col;
01599 }
01600
01601 if (Usage3) {
01602 SM = SUMA_GetStandardMap (SUMA_StandardMapCode(StdType));
01603 if (SM == NULL) {
01604 fprintf (SUMA_STDERR,"Error %s: Error in SUMA_MakeColorMap.\n", FuncName);
01605 exit(1);
01606 }
01607 Ncols = SM->N_Col;
01608 }
01609
01610 M = SM->M;
01611
01612 if (AfniHex && Ncols > 200) {
01613 fprintf (SUMA_STDERR,"Error %s: Cannot write a colormap of more than 200 colors in Afni's hex format.\n", FuncName);
01614 exit(1);
01615 }
01616
01617
01618 if (!AfniHex)
01619 SUMA_disp_mat (M, Ncols, 3, 1);
01620 else {
01621 fprintf (stdout, "\n***COLORS\n");
01622
01623 for (i=0; i < Ncols; ++i) {
01624
01625 r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][0]*255)), 1, 0);
01626 if (i<10) fprintf (stdout, "%s_0%d = #%s", Prfx, i, h);
01627 else fprintf (stdout, "%s_%d = #%s", Prfx, i, h);
01628
01629 r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][1]*255)), 1, 0);
01630 fprintf (stdout, "%s", h);
01631
01632 r_sprintf_long_to_hex (h, (unsigned long)rint((M[i][2]*255)), 1, 0);
01633 fprintf (stdout, "%s\n", h);
01634 }
01635
01636
01637
01638 fprintf (stdout, "\n***PALETTES %s [%d]\n//1 to -1 range\n", Prfx, Ncols);
01639 ifact = 2;
01640 for (i=0; i < Ncols; ++i) {
01641 fprintf (stdout, "%f -> ", 1.0 - (float)(ifact*i)/Ncols);
01642 if (i<10) fprintf (stdout, "%s_0%d\n", Prfx, i);
01643 else fprintf (stdout, "%s_%d\n", Prfx, i);
01644 }
01645 fprintf (stdout, "\n***PALETTES %s [%d+]\n//1 to 0 range\n", Prfx, Ncols);
01646 ifact = 1;
01647 for (i=0; i < Ncols; ++i) {
01648 fprintf (stdout, "%f -> ", 1.0 - (float)(ifact*i)/Ncols);
01649 if (i<10) fprintf (stdout, "%s_0%d\n", Prfx, i);
01650 else fprintf (stdout, "%s_%d\n", Prfx, i);
01651 }
01652 }
01653
01654
01655 if (Usage1) {
01656 if (Fid) SUMA_free2D((char **)Fid, N_Fid / 3);
01657 } else {
01658 if (Fid) SUMA_free2D((char **)Fid, N_Fid / 4);
01659 if (Nind) SUMA_free(Nind);
01660 }
01661 if (SM) SUMA_Free_ColorMap(SM);
01662
01663 if (!SUMA_Free_CommonFields(SUMAg_CF)) { SUMA_SL_Err("Failed to free commonfields."); }
01664
01665 SUMA_RETURN (0);
01666 }
01667 #endif
01668
01669
01670
01671
01672
01673 SUMA_COLOR_MAP *SUMA_CmapOfPlane (SUMA_OVERLAYS *Sover )
01674 {
01675 static char FuncName[]={"SUMA_CmapOfPlane"};
01676 SUMA_COLOR_MAP *ColMap = NULL;
01677 int icmap;
01678
01679 SUMA_ENTRY;
01680
01681 if (!Sover) { SUMA_SL_Err("NULL Sover"); SUMA_RETURN(ColMap); }
01682 if (!Sover->cmapname) { SUMA_SL_Err("NULL Colormap name"); SUMA_RETURN(ColMap); }
01683
01684 if (strcmp(Sover->cmapname, "explicit") == 0) {
01685 SUMA_RETURN(NULL);
01686 }
01687
01688 if (!SUMAg_CF->scm) {
01689 SUMAg_CF->scm = SUMA_Build_Color_maps();
01690 if (!SUMAg_CF->scm) {
01691 SUMA_SL_Err("Can't build color maps");
01692 SUMA_RETURN(ColMap);
01693 }
01694 }
01695 icmap = SUMA_Find_ColorMap ( Sover->cmapname, SUMAg_CF->scm->CMv, SUMAg_CF->scm->N_maps, -2 );
01696 if (icmap < 0) { SUMA_SL_Err("Failed to find ColMap"); SUMA_RETURN(ColMap); }
01697 ColMap = SUMAg_CF->scm->CMv[icmap];
01698
01699 SUMA_RETURN(ColMap);
01700
01701 }
01702
01703
01704
01705
01706
01707
01708
01709
01710 SUMA_Boolean SUMA_RemoveSO_CoordBias(SUMA_SurfaceObject *SO, SUMA_OVERLAYS *ovr)
01711 {
01712 static char FuncName[]={"SUMA_RemoveSO_CoordBias"};
01713 int i, i3;
01714
01715 SUMA_ENTRY;
01716
01717 if (ovr->OptScl->BiasVect) {
01718 switch (ovr->OptScl->DoBias) {
01719 case SW_CoordBias_X:
01720
01721 for (i=0; i < ovr->N_NodeDef; ++i) {
01722 i3 = 3*ovr->NodeDef[i];
01723 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i];
01724 }
01725 break;
01726 case SW_CoordBias_Y:
01727
01728 for (i=0; i < ovr->N_NodeDef; ++i) {
01729 i3 = 3*ovr->NodeDef[i]+1;
01730 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i];
01731 }
01732 break;
01733 case SW_CoordBias_Z:
01734
01735 for (i=0; i < ovr->N_NodeDef; ++i) {
01736 i3 = 3*ovr->NodeDef[i]+2;
01737 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i];
01738 }
01739 break;
01740 case SW_CoordBias_N:
01741
01742 for (i=0; i < ovr->N_NodeDef; ++i) {
01743 i3 = 3*ovr->NodeDef[i];
01744 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3]; ++i3;
01745 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3]; ++i3;
01746 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3];
01747 }
01748 break;
01749 default:
01750 SUMA_SL_Err("This should not be");
01751 SUMA_RETURN(NOPE);
01752 }
01753 } else {
01754 SUMA_SL_Err("DO not call me with no bias!");
01755 SUMA_RETURN(NOPE);
01756 }
01757
01758
01759 SUMA_NewSurfaceGeometry(SO);
01760
01761 SUMA_RETURN(YUP);
01762 }
01763
01764
01765
01766
01767
01768 SUMA_Boolean SUMA_TransferCoordBias(SUMA_OVERLAYS *ovr, SUMA_WIDGET_INDEX_COORDBIAS BiasDim)
01769 {
01770 static char FuncName[]={"SUMA_TransferCoordBias"};
01771 SUMA_SurfaceObject *SO=NULL;
01772 int iso;
01773 SUMA_Boolean LocalHead = NOPE;
01774 SUMA_ENTRY;
01775
01776 if (!ovr) SUMA_RETURN(YUP);
01777
01778 for (iso=0; iso<SUMAg_N_DOv; ++iso) {
01779 if (SUMA_isSO(SUMAg_DOv[iso])) {
01780 SO = (SUMA_SurfaceObject *)SUMAg_DOv[iso].OP;
01781 if (SUMA_isOverlayOfSO(SO, ovr)) {
01782 SUMA_TransferSO_CoordBias(SO, ovr, BiasDim);
01783 }
01784 }
01785 }
01786
01787 SUMA_LH("Setting bias flag");
01788 ovr->OptScl->DoBias = BiasDim;
01789
01790 SUMA_RETURN(YUP);
01791
01792 }
01793
01794
01795
01796
01797 SUMA_Boolean SUMA_TransferSO_CoordBias(SUMA_SurfaceObject *SO, SUMA_OVERLAYS *ovr, SUMA_WIDGET_INDEX_COORDBIAS BiasDim)
01798 {
01799 static char FuncName[]={"SUMA_TransferSO_CoordBias"};
01800 SUMA_Boolean LocalHead = NOPE;
01801 int i, i3;
01802
01803 SUMA_ENTRY;
01804
01805 SUMA_LH("Called");
01806
01807
01808 if (ovr->OptScl->BiasVect) {
01809 SUMA_LH("Removing old bias");
01810
01811 switch (ovr->OptScl->DoBias) {
01812 case SW_CoordBias_X:
01813
01814 for (i=0; i < ovr->N_NodeDef; ++i) {
01815 i3 = 3*ovr->NodeDef[i];
01816 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i];
01817 }
01818 break;
01819 case SW_CoordBias_Y:
01820
01821 for (i=0; i < ovr->N_NodeDef; ++i) {
01822 i3 = 3*ovr->NodeDef[i]+1;
01823 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i];
01824 }
01825 break;
01826 case SW_CoordBias_Z:
01827
01828 for (i=0; i < ovr->N_NodeDef; ++i) {
01829 i3 = 3*ovr->NodeDef[i]+2;
01830 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i];
01831 }
01832 break;
01833 case SW_CoordBias_N:
01834
01835 for (i=0; i < ovr->N_NodeDef; ++i) {
01836 i3 = 3*ovr->NodeDef[i];
01837 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3]; ++i3;
01838 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3]; ++i3;
01839 SO->NodeList[i3] -= ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3];
01840 }
01841 break;
01842 default:
01843 SUMA_SL_Err("This should not be");
01844 SUMA_RETURN(NOPE);
01845 }
01846 SUMA_LH("Adding new bias");
01847
01848 #if 0
01849
01850 switch (BiasDim) {
01851 case SW_CoordBias_X:
01852
01853 for (i=0; i < ovr->N_NodeDef; ++i) {
01854 i3 = 3*ovr->NodeDef[i];
01855 SO->NodeList[i3] += ovr->OptScl->BiasVect[i];
01856 }
01857 break;
01858 case SW_CoordBias_Y:
01859
01860 for (i=0; i < ovr->N_NodeDef; ++i) {
01861 i3 = 3*ovr->NodeDef[i]+1;
01862 SO->NodeList[i3] += ovr->OptScl->BiasVect[i];
01863 }
01864 break;
01865 case SW_CoordBias_Z:
01866
01867 for (i=0; i < ovr->N_NodeDef; ++i) {
01868 i3 = 3*ovr->NodeDef[i]+2;
01869 SO->NodeList[i3] += ovr->OptScl->BiasVect[i];
01870 }
01871 break;
01872 case SW_CoordBias_N:
01873
01874 for (i=0; i < ovr->N_NodeDef; ++i) {
01875 i3 = 3*ovr->NodeDef[i];
01876 SO->NodeList[i3] += ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3]; ++i3;
01877 SO->NodeList[i3] += ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3]; ++i3;
01878 SO->NodeList[i3] += ovr->OptScl->BiasVect[i] * SO->NodeNormList[i3];
01879 }
01880 break;
01881 default:
01882 SUMA_SL_Err("This should not be.\nWhy, oh why ?");
01883 SUMA_RETURN(NOPE);
01884 }
01885 #else
01886
01887 SUMA_ADD_COORD_BIAS_VECT(SO, ovr, BiasDim, ovr->OptScl->BiasVect);
01888 #endif
01889 }
01890
01891
01892 SUMA_NewSurfaceGeometry(SO);
01893 SUMA_RETURN(YUP);
01894 }
01895
01896
01897
01898
01899 SUMA_Boolean SUMA_NewSurfaceGeometry(SUMA_SurfaceObject *SO)
01900 {
01901 static char FuncName[]={"SUMA_NewSurfaceGeometry"};
01902 int ii, i;
01903 SUMA_Boolean LocalHead = NOPE;
01904
01905 SUMA_ENTRY;
01906
01907
01908
01909
01910 SUMA_MIN_MAX_SUM_VECMAT_COL (SO->NodeList, SO->N_Node, SO->NodeDim, SO->MinDims, SO->MaxDims, SO->Center);
01911
01912 SO->Center[0] /= SO->N_Node;
01913 SO->Center[1] /= SO->N_Node;
01914 SO->Center[2] /= SO->N_Node;
01915
01916 SUMA_MIN_VEC (SO->MinDims, 3, SO->aMinDims );
01917 SUMA_MAX_VEC (SO->MaxDims, 3, SO->aMaxDims);
01918
01919
01920 for (ii=0; ii<SUMAg_N_SVv; ++ii) {
01921 if (!SUMAg_SVv[ii].isShaded && SUMAg_SVv[ii].X->TOPLEVEL) {
01922 for (i=0; i< SUMAg_SVv[ii].N_DO; ++i) {
01923 if (SUMA_isSO_G(SUMAg_DOv[SUMAg_SVv[ii].RegisteredDO[i]], SUMAg_SVv[ii].CurGroupName)) {
01924
01925 if (SUMA_findSO_inDOv(SO->idcode_str, SUMAg_DOv, SUMAg_N_DOv) == SUMAg_SVv[ii].RegisteredDO[i]) {
01926
01927 SUMA_LH("Marking Viewer ");
01928 SUMAg_SVv[ii].NewGeom = YUP;
01929 }
01930 }
01931 }
01932 }
01933 }
01934
01935 SUMA_RETURN(YUP);
01936 }
01937
01938
01939
01940
01941
01942
01943
01944
01945
01946
01947
01948 SUMA_Boolean SUMA_SetSO_CoordBias(SUMA_SurfaceObject *SO, SUMA_OVERLAYS *ovr, float *NewBias, SUMA_WIDGET_INDEX_COORDBIAS BiasDim)
01949 {
01950 static char FuncName[]={"SUMA_SetSO_CoordBias"};
01951 int i, i3;
01952 SUMA_Boolean LocalHead = NOPE;
01953
01954 SUMA_ENTRY;
01955
01956 if (!ovr) {
01957 SUMA_SL_Err("NULL ovr");
01958 SUMA_RETURN(NOPE);
01959 }
01960 if (!ovr->NodeDef) {
01961 SUMA_SL_Err("NULL ovr->NodeDef");
01962 SUMA_RETURN(NOPE);
01963 }
01964
01965 if (NewBias) {
01966 #if 0
01967 switch (BiasDim) {
01968 case SW_CoordBias_X:
01969
01970 for (i=0; i < ovr->N_NodeDef; ++i) {
01971 i3 = 3*ovr->NodeDef[i];
01972 SO->NodeList[i3] += NewBias[i];
01973 }
01974 break;
01975 case SW_CoordBias_Y:
01976
01977 for (i=0; i < ovr->N_NodeDef; ++i) {
01978 i3 = 3*ovr->NodeDef[i]+1;
01979 SO->NodeList[i3] += NewBias[i];
01980 }
01981 break;
01982 case SW_CoordBias_Z:
01983
01984 for (i=0; i < ovr->N_NodeDef; ++i) {
01985 i3 = 3*ovr->NodeDef[i]+2;
01986 SO->NodeList[i3] += NewBias[i];
01987 }
01988 break;
01989 case SW_CoordBias_N:
01990
01991 for (i=0; i < ovr->N_NodeDef; ++i) {
01992 i3 = 3*ovr->NodeDef[i];
01993 SO->NodeList[i3] += NewBias[i] * SO->NodeNormList[i3]; ++i3;
01994 SO->NodeList[i3] += NewBias[i] * SO->NodeNormList[i3]; ++i3;
01995 SO->NodeList[i3] += NewBias[i] * SO->NodeNormList[i3];
01996 }
01997 break;
01998 case SW_CoordBias_None:
01999
02000 SUMA_SL_Err("Why are you calling me with SW_CoordBias_None and a non-null NewBias?");
02001 SUMA_RETURN(NOPE);
02002 break;
02003 default:
02004 SUMA_SL_Err("This should not be.\nNot at all.");
02005 SUMA_RETURN(NOPE);
02006 }
02007 #else
02008
02009 SUMA_ADD_COORD_BIAS_VECT(SO, ovr, BiasDim, NewBias);
02010 #endif
02011
02012 } else {
02013
02014 }
02015
02016
02017 SUMA_NewSurfaceGeometry(SO);
02018 SUMA_RETURN(YUP);
02019 }
02020
02021
02022
02023
02024
02025
02026
02027 SUMA_Boolean SUMA_SetCoordBias(SUMA_OVERLAYS *ovr, float *NewBias, SUMA_WIDGET_INDEX_COORDBIAS BiasDim)
02028 {
02029 static char FuncName[]={"SUMA_SetCoordBias"};
02030 int i, i3, iso;
02031 SUMA_SurfaceObject *SO=NULL;
02032 SUMA_Boolean LocalHead = NOPE;
02033 SUMA_ENTRY;
02034
02035 if (!ovr) SUMA_RETURN(YUP);
02036
02037 if (ovr->OptScl->BiasVect ) {
02038 SUMA_SL_Err("Can't have Non NULL bias here");
02039 SUMA_Show_ColorOverlayPlanes(&ovr,1,1);
02040 SUMA_RETURN(NOPE);
02041 }
02042
02043 for (iso=0; iso<SUMAg_N_DOv; ++iso) {
02044 if (SUMA_isSO(SUMAg_DOv[iso])) {
02045 SO = (SUMA_SurfaceObject *)SUMAg_DOv[iso].OP;
02046 if (SUMA_isOverlayOfSO(SO, ovr)) {
02047 SUMA_LH(SO->Label);
02048 SUMA_SetSO_CoordBias(SO, ovr, NewBias, BiasDim);
02049 }
02050 }
02051 }
02052
02053 ovr->OptScl->BiasVect = NewBias;
02054 ovr->OptScl->DoBias = BiasDim;
02055
02056 SUMA_RETURN(YUP);
02057 }
02058
02059 SUMA_Boolean SUMA_RemoveCoordBias(SUMA_OVERLAYS *ovr)
02060 {
02061 static char FuncName[]={"SUMA_RemoveCoordBias"};
02062 int i, i3, iso;
02063 SUMA_SurfaceObject *SO=NULL;
02064 SUMA_Boolean LocalHead = NOPE;
02065 SUMA_ENTRY;
02066
02067 if (!ovr) SUMA_RETURN(YUP);
02068 if (ovr->OptScl->BiasVect) {
02069 for (iso=0; iso<SUMAg_N_DOv; ++iso) {
02070 if (SUMA_isSO(SUMAg_DOv[iso])) {
02071 SO = (SUMA_SurfaceObject *)SUMAg_DOv[iso].OP;
02072 if (SUMA_isOverlayOfSO(SO, ovr)) {
02073 SUMA_LH(SO->Label);
02074 SUMA_RemoveSO_CoordBias(SO, ovr);
02075 }
02076 }
02077 }
02078
02079 SUMA_free(ovr->OptScl->BiasVect);
02080 }
02081 ovr->OptScl->BiasVect = NULL;
02082 ovr->OptScl->DoBias = SW_CoordBias_None;
02083
02084 SUMA_RETURN(YUP);
02085 }
02086
02087
02088
02089
02090
02091
02092
02093
02094
02095
02096
02097
02098 SUMA_Boolean SUMA_ScaleToMap_Interactive ( SUMA_OVERLAYS *Sover )
02099 {
02100 static char FuncName[]={"SUMA_ScaleToMap_Interactive"};
02101 float *V=NULL, *T=NULL, *B=NULL;
02102 int i, icmap, i3, cnt, cnt3, loc[2], *nd=NULL;
02103 float Range[2], minV, maxV, minB, maxB, fact=0.0, floc = 0.0;
02104 SUMA_COLOR_MAP *ColMap = NULL;
02105 SUMA_SCALE_TO_MAP_OPT *Opt = NULL;
02106 SUMA_COLOR_SCALED_VECT * SV = NULL;
02107 float *junk;
02108 SUMA_WIDGET_INDEX_COORDBIAS HoldBiasOpt;
02109 SUMA_Boolean LocalHead = NOPE;
02110
02111 SUMA_ENTRY;
02112
02113
02114 if (!Sover) { SUMA_SL_Err("NULL Sover"); SUMA_RETURN(NOPE); }
02115 if (!Sover->cmapname) { SUMA_SL_Err("NULL Colormap name"); SUMA_RETURN(NOPE); }
02116 if (!SUMAg_CF->scm) {
02117 SUMAg_CF->scm = SUMA_Build_Color_maps();
02118 if (!SUMAg_CF->scm) {
02119 SUMA_SL_Err("Can't build color maps");
02120 SUMA_RETURN(NOPE);
02121 }
02122 }
02123 icmap = SUMA_Find_ColorMap ( Sover->cmapname, SUMAg_CF->scm->CMv, SUMAg_CF->scm->N_maps, -2 );
02124 if (icmap < 0) { SUMA_SL_Err("Failed to find ColMap"); SUMA_RETURN(NOPE); }
02125 ColMap = SUMAg_CF->scm->CMv[icmap];
02126
02127 Opt = Sover->OptScl;
02128
02129
02130 SV = SUMA_Create_ColorScaledVect(Sover->dset_link->dnel->vec_filled);
02131
02132 SUMA_LH("Fetching vetors from dset");
02133 T = NULL; V = NULL; B = NULL;
02134
02135 if (Opt->tind >= 0 && Opt->UseThr) {
02136 SUMA_LH("Fetching Threshold column");
02137
02138 T = SUMA_DsetCol2Float (Sover->dset_link, Opt->tind, 0);
02139 if (!T) { SUMA_SL_Err("Failed to get T"); SUMA_RETURN(NOPE); }
02140 switch (Opt->ThrMode) {
02141 case SUMA_LESS_THAN:
02142 for (i=0; i<Sover->dset_link->dnel->vec_filled; ++i) {
02143 if (T[i] < Opt->ThreshRange[0]) {
02144 SV->isMasked[i] = YUP;
02145 }
02146 }
02147 break;
02148 case SUMA_ABS_LESS_THAN:
02149 for (i=0; i<Sover->dset_link->dnel->vec_filled; ++i) {
02150 if (T[i] < Opt->ThreshRange[0] && T[i] > -Opt->ThreshRange[0]) {
02151 SV->isMasked[i] = YUP;
02152 }
02153 }
02154 break;
02155 case SUMA_THRESH_OUTSIDE_RANGE:
02156 for (i=0; i<Sover->dset_link->dnel->vec_filled; ++i) {
02157 if (T[i] < Opt->ThreshRange[0] || T[i] > Opt->ThreshRange[1]) {
02158 SV->isMasked[i] = YUP;
02159 }
02160 }
02161 break;
02162 case SUMA_THRESH_INSIDE_RANGE:
02163 for (i=0; i<Sover->dset_link->dnel->vec_filled; ++i) {
02164 if (T[i] > Opt->ThreshRange[0] && T[i] < Opt->ThreshRange[1]) {
02165 SV->isMasked[i] = YUP;
02166 }
02167 }
02168 break;
02169 default:
02170 SUMA_SL_Err("Wrond threshold mode");
02171 SUMA_RETURN(NOPE);
02172 break;
02173 }
02174
02175 if (T) SUMA_free(T); T = NULL;
02176 }
02177
02178 SUMA_LH("Fetching Intensity column");
02179 if (Opt->find < 0) { SUMA_SL_Crit("Bad column index.\n"); SUMA_RETURN(NOPE); }
02180 else {
02181
02182 V = SUMA_DsetCol2Float (Sover->dset_link, Opt->find, 0);
02183 if (!V) { SUMA_SL_Err("Failed to get V"); SUMA_RETURN(NOPE); }
02184 }
02185
02186
02187 if (Opt->alaAFNI) {
02188
02189 SUMA_LH("Scaling a la AFNI");
02190 if (!SUMA_ScaleToMap_alaAFNI (V, Sover->dset_link->dnel->vec_filled,
02191 SUMA_LARG_ABS(Opt->IntRange[0], Opt->IntRange[1]),
02192 ColMap, Opt,
02193 SV) ) {
02194 SUMA_SL_Err("Failed in SUMA_ScaleToMap_alaAFNI");
02195 SUMA_RETURN(NOPE);
02196 }
02197 } else {
02198
02199 SUMA_LH("Scaling a la SUMA");
02200 if (!SUMA_ScaleToMap( V, Sover->dset_link->dnel->vec_filled,
02201 Opt->IntRange[0], Opt->IntRange[1],
02202 ColMap, Opt,
02203 SV) ){
02204 SUMA_SL_Err("Failed in SUMA_ScaleToMap");
02205 SUMA_RETURN(NOPE);
02206 }
02207 }
02208
02209
02210 if (Opt->bind >= 0 && Opt->UseBrt) {
02211 SUMA_LH("Brightness modulation needed");
02212
02213 B = SUMA_DsetCol2Float (Sover->dset_link, Opt->bind, 0);
02214 if (!B) { SUMA_SL_Err("Failed to get B"); SUMA_RETURN(NOPE); }
02215
02216 if (Opt->BrightRange[0] && Opt->BrightRange[1]) {
02217
02218 minB = Opt->BrightRange[0]; maxB = Opt->BrightRange[1];
02219 for (i=0; i<Sover->dset_link->dnel->vec_filled; ++i) {
02220 if (!SV->isMasked[i]) {
02221
02222 if (B[i] < Opt->BrightRange[0]) B[i] = Opt->BrightRange[0];
02223 else if (B[i] > Opt->BrightRange[1]) B[i] = Opt->BrightRange[1];
02224 }
02225 }
02226 } else {
02227 if (!SUMA_GetDsetColRange(Sover->dset_link, Opt->bind, Range, loc)) { SUMA_SL_Err("Failed to get ColRange!"); SUMA_RETURN(NOPE); }
02228 minB = Range[0]; maxB = Range[1];
02229 }
02230
02231 SUMA_LH("Scaling by B");
02232 fact = (Opt->BrightMap[1] - Opt->BrightMap[0]) / (maxB - minB);
02233 for (i=0; i<Sover->dset_link->dnel->vec_filled; ++i) {
02234 if (!SV->isMasked[i]) {
02235
02236 i3 = 3*i;
02237 floc = (B[i] - minB) * fact + Opt->BrightMap[0];
02238 SV->cV[i3 ] = SV->cV[i3 ] * floc;
02239 SV->cV[i3 +1] = SV->cV[i3 +1] * floc;
02240 SV->cV[i3 +2] = SV->cV[i3 +2] * floc;
02241 }
02242 }
02243 }
02244
02245
02246 HoldBiasOpt = Opt->DoBias;
02247 if (Opt->DoBias == SW_CoordBias_X || Opt->DoBias == SW_CoordBias_Y || Opt->DoBias == SW_CoordBias_Z || Opt->DoBias == SW_CoordBias_N ) {
02248 SUMA_RemoveCoordBias(Sover);
02249 }
02250
02251
02252 SUMA_LH("Copying into NodeDef");
02253 nd = SUMA_GetNodeDef(Sover->dset_link);
02254 if (nd) {
02255 cnt = 0;
02256 for (i=0; i<Sover->dset_link->dnel->vec_filled; ++i) {
02257 if (!SV->isMasked[i]) {
02258 cnt3 = 3*cnt; i3 = 3*i;
02259 Sover->NodeDef[cnt] = nd[i];
02260 Sover->ColVec[cnt3 ] = SV->cV[i3 ];
02261 Sover->ColVec[cnt3 +1] = SV->cV[i3 +1];
02262 Sover->ColVec[cnt3 +2] = SV->cV[i3 +2];
02263 if (SV->BiasCoordVec) SV->BiasCoordVec[cnt] = SV->BiasCoordVec[i];
02264 ++cnt;
02265 }
02266 }
02267 } else {
02268 cnt = 0;
02269 for (i=0; i<Sover->dset_link->dnel->vec_filled; ++i) {
02270 if (!SV->isMasked[i]) {
02271 cnt3 = 3*cnt; i3 = 3*i;
02272 Sover->NodeDef[cnt] = i;
02273 Sover->ColVec[cnt3 ] = SV->cV[i3 ];
02274 Sover->ColVec[cnt3 +1] = SV->cV[i3 +1];
02275 Sover->ColVec[cnt3 +2] = SV->cV[i3 +2];
02276 if (SV->BiasCoordVec) SV->BiasCoordVec[cnt] = SV->BiasCoordVec[i];
02277 ++cnt;
02278 }
02279 }
02280 }
02281 Sover->N_NodeDef = cnt;
02282 Sover->FullList = NOPE;
02283
02284
02285
02286 switch (HoldBiasOpt) {
02287 case SW_CoordBias_X:
02288 SUMA_LH("Bias X");
02289 SUMA_SetCoordBias(Sover, SV->BiasCoordVec, SW_CoordBias_X);
02290 SV->BiasCoordVec = NULL;
02291 break;
02292 case SW_CoordBias_Y:
02293 SUMA_LH("Bias Y");
02294 SUMA_SetCoordBias(Sover, SV->BiasCoordVec, SW_CoordBias_Y);
02295 SV->BiasCoordVec = NULL;
02296 break;
02297 case SW_CoordBias_Z:
02298 SUMA_LH("Bias Z");
02299 SUMA_SetCoordBias(Sover, SV->BiasCoordVec, SW_CoordBias_Z);
02300 SV->BiasCoordVec = NULL;
02301 break;
02302 case SW_CoordBias_N:
02303 SUMA_LH("Bias N");
02304 SUMA_SetCoordBias(Sover, SV->BiasCoordVec, SW_CoordBias_N);
02305 SV->BiasCoordVec = NULL;
02306 break;
02307 default:
02308 SUMA_LH("Bias None");
02309 break;
02310 }
02311
02312 if (LocalHead) {
02313 SUMA_LH("In Scale_Interactive\n**********************");
02314
02315 }
02316
02317
02318
02319 SUMA_LH("Cleanup, cleanup, everybody cleanup");
02320 if (T) SUMA_free(T); T = NULL;
02321 if (V) SUMA_free(V); V = NULL;
02322 if (B) SUMA_free(B); B = NULL;
02323 if (SV) SUMA_Free_ColorScaledVect (SV); SV = NULL;
02324 SUMA_RETURN(YUP);
02325
02326 }
02327
02328 SUMA_Boolean SUMA_ScaleToMap_alaAFNI ( float *V, int N_V,
02329 float range,
02330 SUMA_COLOR_MAP *ColMap,
02331 SUMA_SCALE_TO_MAP_OPT *Opt,
02332 SUMA_COLOR_SCALED_VECT * SV)
02333 {
02334 static char FuncName[]={"SUMA_ScaleToMap_alaAFNI"};
02335 int i,j, i0, i1, i3, mxColindex;
02336 float Vmin, Vmax, MinCol, MaxCol, Vrange, Vscl, r, **Mbuf= NULL;
02337 SUMA_Boolean NewMap = NOPE;
02338 SUMA_Boolean LocalHead = NOPE;
02339
02340 SUMA_ENTRY;
02341
02342
02343
02344 if (range == 0.0) {
02345
02346 Vmin = V[0]; Vmax = V[0];
02347 for (i=0; i < N_V; ++i) {
02348 if (V[i] > Vmax) Vmax = V[i];
02349 else if (V[i] < Vmin) Vmin = V[i];
02350 }
02351 } else {
02352 if (ColMap->Sgn >= 0) {
02353 Vmin = 0.0;
02354 Vmax = range;
02355 }else {
02356 Vmin = -range;
02357 Vmax = range;
02358 }
02359 }
02360
02361
02362 if (Opt->ApplyMask){
02363 if (Opt->MaskZero) {
02364
02365 for (i=0; i < N_V; ++i) {
02366 if (!V[i] || (V[i] >= Opt->MaskRange[0] && V[i] <= Opt->MaskRange[1]) ) SV->isMasked[i] = YUP;
02367 }
02368 } else {
02369
02370 for (i=0; i < N_V; ++i) {
02371 if (V[i] >= Opt->MaskRange[0] && V[i] <= Opt->MaskRange[1]) SV->isMasked[i] = YUP;
02372 }
02373 }
02374 } else {
02375 if (Opt->MaskZero) {
02376
02377 for (i=0; i < N_V; ++i) {
02378 if (!V[i]) SV->isMasked[i] = YUP;
02379 }
02380 }
02381 }
02382
02383
02384 if (Opt->ApplyClip) {
02385 SUMA_S_Warn("Option Opt->ApplyClip not applicable here.\nOption ignored.");
02386 }
02387 for (i=0; i < N_V; ++i) {
02388 if (!SV->isMasked[i]) {
02389 if (V[i] > Vmin) {
02390
02391 } else {
02392 V[i] = Vmin;
02393 }
02394
02395 if (V[i] < Vmax) {
02396
02397 } else {
02398 V[i] = Vmax;
02399 }
02400 }
02401 }
02402
02403
02404 if (ColMap->frac) {
02405
02406 SUMA_LH("Linearizing colormap ...");
02407 NewMap = YUP;
02408 if (ColMap->frac[0] > 0 && ColMap->Sgn == -1) {
02409 SUMA_S_Warn ("Color map fractions are positive with Sgn flag = -1");
02410 }
02411 if (ColMap->frac[0] < 0 && ColMap->Sgn == 1) {
02412 SUMA_S_Warn ("Color map fractions are negative with Sgn flag = 1");
02413 }
02414 ColMap = SUMA_Linearize_Color_Map (ColMap, -1);
02415 if (LocalHead) {
02416 FILE *lincmap=NULL;
02417 int ii = 0;
02418 lincmap=fopen("./lincmap.1D", "w");
02419 if (lincmap) {
02420 SUMA_LH("Linearized map written to ./lincmap.1D");
02421
02422
02423 for (ii=ColMap->N_Col-1; ii >=0; --ii) {
02424 fprintf (lincmap, "%d\t%f\t%f\t%f\n", ii, ColMap->M[ii][0], ColMap->M[ii][1],ColMap->M[ii][2]);
02425 }
02426 fclose (lincmap); lincmap = NULL;
02427 }else {
02428 SUMA_SL_Err("Failed to write linearized colormap to file.\nProceeding...");
02429 }
02430 }
02431
02432 }else {
02433 SUMA_LH("NO Linearizing of colormap deemed necessary...");
02434 NewMap = NOPE;
02435 }
02436
02437
02438 Mbuf = NULL;
02439 if (Opt->BrightFact <= 0 || Opt->BrightFact > 1) {
02440 fprintf (SUMA_STDERR,"Error %s: Opt->BrightFact must be between ]0 1]\n", FuncName);
02441 SUMA_RETURN (NOPE);
02442 }else {
02443 if (Opt->BrightFact != 1) {
02444 Mbuf = ColMap->M;
02445 ColMap->M = (float **)SUMA_allocate2D(ColMap->N_Col, 3, sizeof(float));
02446 for (i=0; i < ColMap->N_Col; ++i) {
02447 ColMap->M[i][0] = Mbuf[i][0] * Opt->BrightFact;
02448 ColMap->M[i][1] = Mbuf[i][1] * Opt->BrightFact;
02449 ColMap->M[i][2] = Mbuf[i][2] * Opt->BrightFact;
02450 }
02451
02452 Opt->MaskColor[0] *= Opt->BrightFact;
02453 Opt->MaskColor[1] *= Opt->BrightFact;
02454 Opt->MaskColor[2] *= Opt->BrightFact;
02455 }
02456 }
02457
02458 if (Opt->interpmode != SUMA_DIRECT && Opt->interpmode != SUMA_NO_INTERP && Opt->interpmode != SUMA_INTERP) {
02459 fprintf (SUMA_STDERR,"Error %s: Opt->interpmode is incorrectly specifed (%d).\n", FuncName, Opt->interpmode);
02460 SUMA_RETURN(NOPE);
02461 }
02462
02463 if (Opt->interpmode == SUMA_INTERP || Opt->interpmode == SUMA_NO_INTERP) {
02464
02465 MinCol = 0.0; MaxCol = (float)ColMap->N_Col;
02466 Vrange = Vmax - Vmin;
02467 if (LocalHead) fprintf(SUMA_STDERR,"%s: [Vrange, Vmax, Vmin] = [%f, %f, %f]\nInterpMode=%d\n",
02468 FuncName, Vrange, Vmax, Vmin, Opt->interpmode);
02469 if (Vrange < 0) {
02470 fprintf (SUMA_STDERR,"Error %s: Vmax < Vmin.\n", FuncName);
02471 SUMA_RETURN (NOPE);
02472 }
02473
02474 if (Vrange > 0) {
02475 mxColindex = ColMap->N_Col -1;
02476 if (Opt->interpmode == SUMA_NO_INTERP) {
02477 SUMA_LH("No_Interp mode");
02478 for (i=0; i < N_V; ++i) {
02479 i3 = 3*i;
02480 if (!SV->isMasked[i]) {
02481 Vscl = (V[i] - Vmin) / Vrange * ColMap->N_Col;
02482 if (Vscl < 0) Vscl = 0; if (Vscl > ColMap->N_Col) Vscl = ColMap->N_Col;
02483 i0 = (int)(Vscl);
02484 if (i0 > mxColindex) i0 = mxColindex;
02485 if (LocalHead) {
02486 fprintf(SUMA_STDERR,"%s: %f-->%f: Colmap index is %d\n", FuncName, V[i], Vscl, i0);
02487 }
02488 if (ColMap->M[i0][0] >= 0) {
02489 SV->cV[i3 ] = ColMap->M[i0][0];
02490 SV->cV[i3+1] = ColMap->M[i0][1];
02491 SV->cV[i3+2] = ColMap->M[i0][2];
02492 } else {
02493 SV->isMasked[i] = YUP;
02494 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02495 }
02496 } else {
02497 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02498 }
02499 if (LocalHead) {
02500 fprintf(SUMA_STDERR,"%s: %f-->[%f %f %f]\n", FuncName, V[i], SV->cV[i3 ], SV->cV[i3+1], SV->cV[i3+2]);
02501 }
02502 }
02503 } else {
02504 SUMA_LH("Interp mode");
02505 for (i=0; i < N_V; ++i) {
02506 i3 = 3*i;
02507 if (!SV->isMasked[i]) {
02508 Vscl = (V[i] - Vmin) / Vrange * ColMap->N_Col;
02509 if (Vscl < 0) Vscl = 0; if (Vscl > ColMap->N_Col) Vscl = ColMap->N_Col;
02510
02511 i0 = (int)(Vscl);
02512 if (i0 > mxColindex) i0 = mxColindex;
02513 i1=i0+1;
02514
02515 if (ColMap->M[i0][0] >= 0) {
02516 if (i1 < ColMap->N_Col) {
02517 r = Vscl - i0;
02518
02519
02520
02521 SV->cV[i3 ] = ColMap->M[i0][0] + r * (ColMap->M[i1][0] - ColMap->M[i0][0]);
02522 SV->cV[i3+1] = ColMap->M[i0][1] + r * (ColMap->M[i1][1] - ColMap->M[i0][1]);
02523 SV->cV[i3+2] = ColMap->M[i0][2] + r * (ColMap->M[i1][2] - ColMap->M[i0][2]);
02524 } else {
02525 SV->cV[i3 ] = ColMap->M[i0][0];
02526 SV->cV[i3+1] = ColMap->M[i0][1];
02527 SV->cV[i3+2] = ColMap->M[i0][2];
02528 }
02529 } else {
02530 SV->isMasked[i] = YUP;
02531 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02532 }
02533 } else {
02534 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02535 }
02536 }
02537 }
02538 } else {
02539 fprintf (SUMA_STDOUT,"Warning %s: Node value range is 0, using middle color in colormap.\n", FuncName);
02540 i0 = (ColMap->N_Col - 1)/2;
02541 for (i=0; i < N_V; ++i) {
02542 i3 = 3*i;
02543 if (!SV->isMasked[i]) {
02544 if (ColMap->M[i0][0] >= 0) {
02545 SV->cV[i3 ] = ColMap->M[i0][0];
02546 SV->cV[i3+1] = ColMap->M[i0][1];
02547 SV->cV[i3+2] = ColMap->M[i0][2];
02548 } else {
02549 SV->isMasked[i] = YUP;
02550 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02551 }
02552 } else {
02553 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02554 }
02555 }
02556 }
02557 } else {
02558
02559 SUMA_LH("Direct colormapping");
02560 if (Opt->interpmode != SUMA_DIRECT) {
02561 fprintf (SUMA_STDOUT,"Error %s: Logic error, should never get here with Opt->interpmode != SUMA_DIRECT\n", FuncName);
02562 SUMA_RETURN(NOPE);
02563 }
02564 for (i=0; i < N_V; ++i) {
02565 i3 = 3*i;
02566 if (!SV->isMasked[i]) {
02567 i0 = (int)V[i];
02568 if (i0 < 0) i0 = 0;
02569 else if (i0 >= ColMap->N_Col) i0 = ColMap->N_Col -1;
02570 if (ColMap->M[i0][0] >= 0) {
02571 SV->cV[i3 ] = ColMap->M[i0][0];
02572 SV->cV[i3+1] = ColMap->M[i0][1];
02573 SV->cV[i3+2] = ColMap->M[i0][2];
02574 } else {
02575 SV->isMasked[i] = YUP;
02576 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02577 }
02578 } else {
02579 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02580 }
02581
02582 }
02583 }
02584 if (Mbuf) {
02585
02586 SUMA_free2D((char **)ColMap->M, ColMap->N_Col);
02587 ColMap->M = Mbuf; Mbuf = NULL;
02588 }
02589 if (NewMap) {
02590 SUMA_LH("Freeing linearized colormap.");
02591 SUMA_Free_ColorMap (ColMap);
02592 }
02593
02594 SUMA_RETURN (YUP);
02595
02596 }
02597
02598
02599
02600
02601
02602
02603
02604
02605
02606
02607
02608
02609
02610
02611
02612
02613
02614
02615
02616
02617
02618
02619
02620
02621
02622
02623
02624 SUMA_Boolean SUMA_ScaleToMap (float *V, int N_V,
02625 float Vmin, float Vmax,
02626 SUMA_COLOR_MAP *ColMap,
02627 SUMA_SCALE_TO_MAP_OPT *Opt,
02628 SUMA_COLOR_SCALED_VECT * SV)
02629 {
02630 static char FuncName[]={"SUMA_ScaleToMap"};
02631 int i,j, i0, i1, mxColindex, i3=0;
02632 float MinCol, MaxCol, Vrange, Vscl, r, **Mbuf= NULL;
02633 SUMA_Boolean NewMap = NOPE;
02634 SUMA_Boolean LocalHead = NOPE;
02635
02636 SUMA_ENTRY;
02637
02638 if (!ColMap) {
02639 SUMA_SL_Err("NULL ColMap");
02640 SUMA_RETURN(NOPE);
02641 }
02642 if (!Opt) {
02643 SUMA_SL_Err("NULL Opt");
02644 SUMA_RETURN(NOPE);
02645 }
02646 if (!SV) {
02647 SUMA_SL_Err("NULL SV");
02648 SUMA_RETURN(NOPE);
02649 }
02650 if (!V) {
02651 SUMA_SL_Err("NULL V");
02652 SUMA_RETURN(NOPE);
02653 }
02654
02655
02656 if (ColMap->Sgn < 0) {
02657
02658
02659 SUMA_LH("Colormap is split into positive and negative.\n Make sure your range is from -a to + a to have the mapping resemble AFNI's");
02660 }
02661
02662
02663 if (Opt->ApplyMask){
02664 SUMA_LH("Applying Mask");
02665 if (Opt->MaskZero) {
02666
02667 for (i=0; i < N_V; ++i) {
02668 if (!V[i] || (V[i] >= Opt->MaskRange[0] && V[i] <= Opt->MaskRange[1])) SV->isMasked[i] = YUP;
02669 }
02670 } else {
02671
02672 for (i=0; i < N_V; ++i) {
02673 if (V[i] >= Opt->MaskRange[0] && V[i] <= Opt->MaskRange[1]) SV->isMasked[i] = YUP;
02674 }
02675 }
02676 }else {
02677 if (Opt->MaskZero) {
02678 SUMA_LH("Masking Zeros");
02679
02680 for (i=0; i < N_V; ++i) {
02681 if (!V[i]) SV->isMasked[i] = YUP;
02682 }
02683 }
02684 }
02685
02686
02687 if (Opt->ApplyClip) {
02688 SUMA_LH( "Applying Clip \n"
02689 "(This one's not used in\n"
02690 " interactive mode anymore \n"
02691 " because clipping is handled \n"
02692 " in the colormapping part)");
02693 for (i=0; i < N_V; ++i) {
02694 if (!SV->isMasked[i]) {
02695 if (V[i] > Opt->IntRange[0]) {
02696
02697 } else {
02698 V[i] = Opt->IntRange[0];
02699 }
02700
02701 if (V[i] < Opt->IntRange[1]) {
02702
02703 } else {
02704 V[i] = Opt->IntRange[1];
02705 }
02706 }
02707 }
02708 Vmin = Opt->IntRange[0];
02709 Vmax = Opt->IntRange[1];
02710 }
02711
02712
02713 if (Opt->DoBias == SW_CoordBias_X || Opt->DoBias == SW_CoordBias_Y || Opt->DoBias == SW_CoordBias_Z || Opt->DoBias == SW_CoordBias_N) {
02714 SUMA_LH("Coord Bias requested");
02715 if (!SV->BiasCoordVec) {
02716 SUMA_LH("Allocating for BiasCoordVec");
02717 SV->BiasCoordVec = (float *)SUMA_calloc(N_V, sizeof(float));
02718 if (!SV->BiasCoordVec) { SUMA_SL_Crit("Failed to allocate"); SUMA_RETURN(NOPE); }
02719 }else {
02720 SUMA_SL_Err("Do not expect this not to be null here ... ");
02721 SUMA_RETURN(NOPE);
02722 }
02723 } else {
02724 SUMA_LH("No Coord Bias requested");
02725 if (SV->BiasCoordVec) {
02726 SUMA_SL_Err("Do NOT expect this not to be null here ... ");
02727 SUMA_RETURN(NOPE);
02728 }
02729 }
02730
02731
02732 if (ColMap->frac) {
02733 if (Opt->interpmode == SUMA_NO_INTERP || Opt->interpmode == SUMA_INTERP) {
02734
02735 SUMA_LH("Linearizing colormap ...");
02736 NewMap = YUP;
02737 if (ColMap->frac[0] > 0 && ColMap->Sgn == -1) {
02738 SUMA_S_Warn ("Color map fractions are positive with Sgn flag = -1");
02739 }
02740 if (ColMap->frac[0] < 0 && ColMap->Sgn == 1) {
02741 SUMA_S_Warn ("Color map fractions are negative with Sgn flag = 1");
02742 }
02743 ColMap = SUMA_Linearize_Color_Map (ColMap, -1);
02744 } else {
02745 if (Opt->interpmode != SUMA_DIRECT) {
02746 SUMA_SL_Err("Not expected interpmode.");
02747
02748 NewMap = NOPE;
02749 }
02750 }
02751 }else {
02752 SUMA_LH("NO Linearizing of colormap deemed necessary...");
02753 NewMap = NOPE;
02754 }
02755
02756
02757 Mbuf = NULL;
02758 if (Opt->BrightFact <= 0 || Opt->BrightFact > 1) {
02759 fprintf (SUMA_STDERR,"Error %s: Opt->BrightFact must be between ]0 1]\n", FuncName);
02760 SUMA_RETURN (NOPE);
02761 }else {
02762 if (Opt->BrightFact != 1) {
02763 SUMA_LH("Modulating brightness of map");
02764 Mbuf = ColMap->M;
02765 ColMap->M = (float **)SUMA_allocate2D(ColMap->N_Col, 3, sizeof(float));
02766 for (i=0; i < ColMap->N_Col; ++i) {
02767 ColMap->M[i][0] = Mbuf[i][0] * Opt->BrightFact;
02768 ColMap->M[i][1] = Mbuf[i][1] * Opt->BrightFact;
02769 ColMap->M[i][2] = Mbuf[i][2] * Opt->BrightFact;
02770 }
02771
02772 Opt->MaskColor[0] *= Opt->BrightFact;
02773 Opt->MaskColor[1] *= Opt->BrightFact;
02774 Opt->MaskColor[2] *= Opt->BrightFact;
02775 }
02776 }
02777
02778
02779 if (Opt->interpmode != SUMA_DIRECT && Opt->interpmode != SUMA_NO_INTERP && Opt->interpmode != SUMA_INTERP) {
02780 fprintf (SUMA_STDERR,"Error %s: Opt->interpmode is incorrectly specifed (%d).\n", FuncName, Opt->interpmode);
02781 SUMA_RETURN(NOPE);
02782 }
02783
02784 if (Opt->interpmode == SUMA_NO_INTERP || Opt->interpmode == SUMA_INTERP) {
02785
02786 MinCol = 0.0; MaxCol = (float)ColMap->N_Col;
02787 Vrange = Vmax - Vmin;
02788 if (Vrange < 0) {
02789 fprintf (SUMA_STDERR,"Error %s: Vmax < Vmin.\n", FuncName);
02790 SUMA_RETURN (NOPE);
02791 }
02792
02793 if (Vrange > 0) {
02794 mxColindex = ColMap->N_Col -1;
02795 if (Opt->interpmode == SUMA_NO_INTERP) {
02796 SUMA_LH("No Interp Mode");
02797 for (i=0; i < N_V; ++i) {
02798 i3 = 3*i;
02799 if (!SV->isMasked[i]) {
02800 Vscl = (V[i] - Vmin) / Vrange * ColMap->N_Col;
02801 if (Vscl < 0) Vscl = 0; if (Vscl > ColMap->N_Col) Vscl = ColMap->N_Col;
02802 i0 = (int)(Vscl);
02803 if (i0 > mxColindex) i0 = mxColindex;
02804 if (SV->BiasCoordVec) SV->BiasCoordVec[i] = Vscl;
02805 if (ColMap->M[i0][0] >= 0) {
02806 SV->cV[i3 ] = ColMap->M[i0][0];
02807 SV->cV[i3+1] = ColMap->M[i0][1];
02808 SV->cV[i3+2] = ColMap->M[i0][2];
02809 } else {
02810 SV->isMasked[i] = YUP;
02811 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02812 }
02813 } else {
02814 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02815 }
02816 }
02817 } else {
02818 SUMA_LH("Interp Mode");
02819 for (i=0; i < N_V; ++i) {
02820 i3 = 3*i;
02821 if (!SV->isMasked[i]) {
02822 Vscl = (V[i] - Vmin) / Vrange * ColMap->N_Col;
02823 if (Vscl < 0) Vscl = 0; if (Vscl > ColMap->N_Col) Vscl = ColMap->N_Col;
02824
02825 i0 = (int)(Vscl);
02826 if (i0 > mxColindex) i0 = mxColindex;
02827 i1=i0+1;
02828 if (SV->BiasCoordVec) {
02829 SV->BiasCoordVec[i] = Vscl;
02830 }
02831
02832 if (ColMap->M[i0][0] >= 0) {
02833 if (i1 < ColMap->N_Col) {
02834 r = Vscl - i0;
02835 SV->cV[i3 ] = ColMap->M[i0][0] + r * (ColMap->M[i1][0] - ColMap->M[i0][0]);
02836 SV->cV[i3+1] = ColMap->M[i0][1] + r * (ColMap->M[i1][1] - ColMap->M[i0][1]);
02837 SV->cV[i3+2] = ColMap->M[i0][2] + r * (ColMap->M[i1][2] - ColMap->M[i0][2]);
02838 } else {
02839 SV->cV[i3 ] = ColMap->M[i0][0];
02840 SV->cV[i3+1] = ColMap->M[i0][1];
02841 SV->cV[i3+2] = ColMap->M[i0][2];
02842 }
02843 } else {
02844 SV->isMasked[i] = YUP;
02845 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02846 }
02847 } else {
02848 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02849 }
02850 }
02851 }
02852 }else {
02853 fprintf (SUMA_STDOUT,"Warning %s: Node value range is 0, using middle color in colormap.\n", FuncName);
02854 i0 = (ColMap->N_Col - 1)/2;
02855 for (i=0; i < N_V; ++i) {
02856 i3 = 3 * i;
02857 if (!SV->isMasked[i]) {
02858 if (SV->BiasCoordVec) SV->BiasCoordVec[i] = i0;
02859 SV->cV[i3 ] = ColMap->M[i0][0];
02860 SV->cV[i3+1] = ColMap->M[i0][1];
02861 SV->cV[i3+2] = ColMap->M[i0][2];
02862 } else {
02863 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02864 }
02865 }
02866 }
02867 } else {
02868
02869 SUMA_LH( "Direct colormapping.\n"
02870 "Opt->IntRange values are \n"
02871 "meaningless" );
02872 if (Opt->interpmode != SUMA_DIRECT) {
02873 fprintf (SUMA_STDOUT,"Error %s: Logic error, should never get here with Opt->interpmode != SUMA_DIRECT\n", FuncName);
02874 SUMA_RETURN(NOPE);
02875 }
02876 for (i=0; i < N_V; ++i) {
02877 i3 = 3*i;
02878 if (!SV->isMasked[i]) {
02879 i0 = (int)V[i];
02880 if (i0 < 0) i0 = 0;
02881 else if (i0 >= ColMap->N_Col) i0 = ColMap->N_Col -1;
02882 if (ColMap->M[i0][0] >= 0) {
02883 SV->cV[i3 ] = ColMap->M[i0][0];
02884 SV->cV[i3+1] = ColMap->M[i0][1];
02885 SV->cV[i3+2] = ColMap->M[i0][2];
02886 if (SV->BiasCoordVec) SV->BiasCoordVec[i] = i0;
02887 } else {
02888 SV->isMasked[i] = YUP;
02889 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02890 }
02891 } else {
02892 SV->cV[i3 ] = Opt->MaskColor[0]; SV->cV[i3+1] = Opt->MaskColor[1]; SV->cV[i3+2] = Opt->MaskColor[2];
02893 }
02894
02895 }
02896
02897 }
02898
02899
02900 Vrange = (Opt->CoordBiasRange[1] - Opt->CoordBiasRange[0]) / ColMap->N_Col;
02901 if (SV->BiasCoordVec) {
02902 SUMA_LH("Adding the CoordBias");
02903 for (i=0; i < N_V; ++i) {
02904 if (!SV->isMasked[i]) {
02905 SV->BiasCoordVec[i] = Opt->CoordBiasRange[0] + SV->BiasCoordVec[i] * Vrange;
02906
02907 } else SV->BiasCoordVec[i] = 0.0;
02908 }
02909 }
02910
02911 if (Mbuf) {
02912
02913 SUMA_free2D((char **)ColMap->M, ColMap->N_Col);
02914 ColMap->M = Mbuf; Mbuf = NULL;
02915 }
02916 if (NewMap) {
02917 SUMA_LH("Freeing linearized colormap.");
02918 SUMA_Free_ColorMap (ColMap);
02919 }
02920
02921 SUMA_RETURN (YUP);
02922 }
02923
02924
02925
02926
02927
02928
02929
02930
02931
02932
02933 SUMA_COLOR_SCALED_VECT * SUMA_Create_ColorScaledVect(int N_Node)
02934 {
02935 static char FuncName[]={"SUMA_Create_ColorScaledVect"};
02936 SUMA_COLOR_SCALED_VECT * S;
02937 SUMA_Boolean LocalHead = NOPE;
02938
02939 SUMA_ENTRY;
02940 if (LocalHead) fprintf (SUMA_STDERR,"%s:\n Allocate for %d nodes ...\n", FuncName, N_Node);
02941 S = (SUMA_COLOR_SCALED_VECT *)SUMA_malloc(sizeof(SUMA_COLOR_SCALED_VECT));
02942 if (S == NULL) {
02943 fprintf(SUMA_STDERR, "Error %s: Failed to allocate for S.\n", FuncName);
02944 SUMA_RETURN (S);
02945 }
02946
02947
02948 S->cV = (float *) SUMA_calloc(N_Node * 3, sizeof(float));
02949 S->isMasked = (SUMA_Boolean *)SUMA_calloc(N_Node, sizeof(SUMA_Boolean));
02950 S->BiasCoordVec = NULL;
02951
02952 if (!S->cV || !S->isMasked) {
02953 fprintf(SUMA_STDERR, "Error %s: Failed to allocate for S->cV or S->isMasked.\n", FuncName);
02954 SUMA_free(S); S = NULL;
02955 SUMA_RETURN (S);
02956 }
02957
02958 S->N_Node = N_Node;
02959
02960
02961 SUMA_RETURN(S);
02962 }
02963
02964
02965
02966
02967
02968
02969
02970 void SUMA_Free_ColorScaledVect (SUMA_COLOR_SCALED_VECT * S)
02971 {
02972 static char FuncName[]={"SUMA_Free_ColorScaledVect"};
02973
02974 SUMA_ENTRY;
02975
02976 if (S->cV) SUMA_free(S->cV);
02977 if (S->isMasked) SUMA_free(S->isMasked);
02978 if (S->BiasCoordVec) SUMA_free(S->BiasCoordVec);
02979 if (S) SUMA_free(S);
02980 SUMA_RETURNe;
02981 }
02982
02983
02984
02985
02986
02987
02988
02989
02990
02991
02992
02993
02994
02995
02996
02997
02998
02999 SUMA_SCALE_TO_MAP_OPT * SUMA_ScaleToMapOptInit(void)
03000 {
03001 SUMA_SCALE_TO_MAP_OPT * Opt;
03002 static char FuncName[]={"SUMA_ScaleToMapOptInit"};
03003
03004 SUMA_ENTRY;
03005
03006 Opt = (SUMA_SCALE_TO_MAP_OPT *)SUMA_malloc(sizeof(SUMA_SCALE_TO_MAP_OPT));
03007
03008 if (Opt == NULL) {
03009 fprintf (SUMA_STDERR, "Error %s: Could not allocate for Opt.\n", FuncName);
03010 SUMA_RETURN (NULL);
03011 }
03012
03013 Opt->ApplyMask = NOPE;
03014 Opt->MaskRange[0] = Opt->MaskRange[1] = 0.0;
03015 Opt->MaskColor[0] = Opt->MaskColor[1] = Opt->MaskColor[2] = 0.0;
03016 Opt->ApplyClip = NOPE;
03017 Opt->IntRange[0] = Opt->IntRange[1] = 0.0;
03018 Opt->ThreshRange[0] = Opt->ThreshRange[1] = 0.0;
03019 Opt->BrightRange[0] = 0.0; Opt->BrightRange[1] = 0.0;
03020 Opt->BrightMap[0] = 0.3; Opt->BrightMap[1] = 0.8;
03021 Opt->BrightFact = 1.0;
03022 Opt->interpmode = SUMA_INTERP;
03023 Opt->alaAFNI = NOPE;
03024 Opt->AutoIntRange = YUP;
03025 Opt->AutoBrtRange = YUP;
03026 {
03027 char *eee = getenv("SUMA_MaskZero");
03028 if (eee) {
03029 if (strcmp(eee,"NO") == 0) Opt->MaskZero = NOPE;
03030 else if (strcmp(eee,"YES") == 0) Opt->MaskZero = YUP;
03031 else {
03032 fprintf (SUMA_STDERR, "Warning %s:\n"
03033 "Bad value for environment variable SUMA_MaskZero\n"
03034 "Assuming default of YES", FuncName);
03035 Opt->MaskZero = YUP;
03036 }
03037 } else Opt->MaskZero = YUP;
03038 }
03039
03040 Opt->find = 0;
03041 Opt->tind = 0;
03042 Opt->bind = 0;
03043 Opt->UseThr = NOPE;
03044 {
03045 char *eee = getenv("SUMA_AbsThreshold");
03046 if (eee) {
03047 if (strcmp(eee,"NO") == 0) Opt->ThrMode = SUMA_LESS_THAN;
03048 else if (strcmp(eee,"YES") == 0) Opt->ThrMode = SUMA_ABS_LESS_THAN;
03049 else {
03050 fprintf (SUMA_STDERR, "Warning %s:\n"
03051 "Bad value for environment variable SUMA_AbsThresh_tbold\n"
03052 "Assuming default of YES", FuncName);
03053 Opt->ThrMode = SUMA_ABS_LESS_THAN;
03054 }
03055 } else Opt->ThrMode = SUMA_ABS_LESS_THAN;
03056 }
03057
03058 Opt->UseBrt = NOPE;
03059 Opt->DoBias = SW_CoordBias_None;
03060 Opt->BiasVect = NULL;
03061 Opt->CoordBiasRange[0] = 0.0; Opt->CoordBiasRange[1] = 10.0;
03062 SUMA_RETURN (Opt);
03063
03064 }
03065
03066
03067
03068
03069
03070
03071
03072
03073
03074
03075
03076 char *SUMA_StandardMapName (SUMA_STANDARD_CMAP mapcode, int *N_col)
03077 {
03078 static char FuncName[]={"SUMA_StandardMapName"};
03079
03080 SUMA_ENTRY;
03081
03082 *N_col = -1;
03083 switch (mapcode) {
03084 case SUMA_CMAP_ERROR:
03085 SUMA_RETURN("Error");
03086 break;
03087 case SUMA_CMAP_UNDEFINED:
03088 SUMA_RETURN("Undefined");
03089 break;
03090 case SUMA_CMAP_RGYBR20:
03091 *N_col = 20;
03092 SUMA_RETURN("rgybr20");
03093 break;
03094 case SUMA_CMAP_nGRAY20:
03095 *N_col = 20;
03096 SUMA_RETURN("ngray20");
03097 break;
03098 case SUMA_CMAP_GRAY02:
03099 *N_col = 02;
03100 SUMA_RETURN("gray02");
03101 break;
03102 case SUMA_CMAP_flpGRAY02:
03103 *N_col = 02;
03104 SUMA_RETURN("gray_i02");
03105 break;
03106 case SUMA_CMAP_GRAY20:
03107 *N_col = 20;
03108 SUMA_RETURN("gray20");
03109 break;
03110 case SUMA_CMAP_BW20:
03111 *N_col = 20;
03112 SUMA_RETURN("bw20");
03113 break;
03114 case SUMA_CMAP_BGYR19:
03115 *N_col = 19;
03116 SUMA_RETURN("bgyr19");
03117 break;
03118 case SUMA_CMAP_MATLAB_DEF_BYR64:
03119 *N_col = 64;
03120 SUMA_RETURN("byr64");
03121 break;
03122 case SUMA_CMAP_BGYR64:
03123 *N_col = 64;
03124 SUMA_RETURN("bgyr64");
03125 break;
03126 case SUMA_CMAP_ROI256:
03127 *N_col = 256;
03128 SUMA_RETURN("roi256");
03129 break;
03130 case SUMA_CMAP_ROI128:
03131 *N_col = 128;
03132 SUMA_RETURN("roi128");
03133 break;
03134 case SUMA_CMAP_ROI64:
03135 *N_col = 64;
03136 SUMA_RETURN("roi64");
03137 break;
03138 default:
03139 SUMA_RETURN("Cowabonga-x321");
03140 break;
03141 }
03142 }
03143
03144
03145
03146
03147
03148
03149 SUMA_STANDARD_CMAP SUMA_StandardMapCode (char *Name)
03150 {
03151 static char FuncName[]={"SUMA_StandardMapCode"};
03152
03153 SUMA_ENTRY;
03154
03155 if (!Name) SUMA_RETURN(SUMA_CMAP_ERROR);
03156 SUMA_TO_LOWER(Name);
03157 if (!strcmp(Name, "undefined")) SUMA_RETURN(SUMA_CMAP_UNDEFINED);
03158 if (!strcmp(Name, "rgybr20")) SUMA_RETURN(SUMA_CMAP_RGYBR20);
03159 if (!strcmp(Name, "ngray20")) SUMA_RETURN(SUMA_CMAP_nGRAY20);
03160 if (!strcmp(Name, "gray20")) SUMA_RETURN(SUMA_CMAP_GRAY20);
03161 if (!strcmp(Name, "gray02")) SUMA_RETURN(SUMA_CMAP_GRAY02);
03162 if (!strcmp(Name, "gray_i02")) SUMA_RETURN(SUMA_CMAP_flpGRAY02);
03163 if (!strcmp(Name, "bw20")) SUMA_RETURN(SUMA_CMAP_BW20);
03164 if (!strcmp(Name, "bgyr19")) SUMA_RETURN(SUMA_CMAP_BGYR19);
03165 if (!strcmp(Name, "matlab_default_byr64")) SUMA_RETURN(SUMA_CMAP_MATLAB_DEF_BYR64);
03166 if (!strcmp(Name, "byr64")) SUMA_RETURN(SUMA_CMAP_MATLAB_DEF_BYR64);
03167 if (!strcmp(Name, "bgyr64")) SUMA_RETURN(SUMA_CMAP_BGYR64);
03168 if (!strcmp(Name, "ygbrp64")) SUMA_RETURN(SUMA_CMAP_ROI64);
03169 if (!strcmp(Name, "roi64")) SUMA_RETURN(SUMA_CMAP_ROI64);
03170 if (!strcmp(Name, "ygbrp128")) SUMA_RETURN(SUMA_CMAP_ROI128);
03171 if (!strcmp(Name, "ygbrp256")) SUMA_RETURN(SUMA_CMAP_ROI256);
03172 if (!strcmp(Name, "roi128")) SUMA_RETURN(SUMA_CMAP_ROI128);
03173 if (!strcmp(Name, "roi256")) SUMA_RETURN(SUMA_CMAP_ROI256);
03174
03175 SUMA_RETURN(SUMA_CMAP_ERROR);
03176 }
03177
03178
03179
03180
03181
03182
03183
03184
03185
03186
03187
03188
03189
03190
03191
03192
03193 SUMA_COLOR_MAP * SUMA_GetStandardMap (SUMA_STANDARD_CMAP mapcode)
03194 { static char FuncName[]={"SUMA_GetStandardMap"};
03195 float **Fiducials;
03196 int k, nc;
03197 int *Nind;
03198 int Ncols, NFid;
03199 SUMA_COLOR_MAP * CM;
03200
03201 SUMA_ENTRY;
03202
03203 switch (mapcode) {
03204 case SUMA_CMAP_RGYBR20:
03205 {
03206 Fiducials = (float **)SUMA_allocate2D(5, 3, sizeof(float));
03207 if (!Fiducials) {
03208 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials.\n", FuncName);
03209 SUMA_RETURN (NULL);
03210 }
03211
03212 k = 0;
03213 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; ++k;
03214 Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; ++k;
03215 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 1.0; ++k;
03216 Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; ++k;
03217 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; ++k;
03218
03219
03220 CM = SUMA_MakeColorMap (Fiducials, k, 20, YUP, SUMA_StandardMapName(mapcode,&nc));
03221
03222 SUMA_free2D((char **)Fiducials, k);
03223
03224 if (!CM) {
03225 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03226 SUMA_RETURN (NULL);
03227 }
03228 break;
03229 }
03230 case SUMA_CMAP_BGYR19:
03231 {
03232 Fiducials = (float **)SUMA_allocate2D(4, 3, sizeof(float));
03233 if (!Fiducials) {
03234 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials.\n", FuncName);
03235 SUMA_RETURN (NULL);
03236 }
03237
03238 k = 0;
03239 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 1.0; ++k;
03240 Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; ++k;
03241 Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; ++k;
03242 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; ++k;
03243
03244
03245 CM = SUMA_MakeColorMap (Fiducials, k, 19, NOPE, SUMA_StandardMapName(mapcode,&nc));
03246
03247 SUMA_free2D((char **)Fiducials, k);
03248
03249 if (!CM) {
03250 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03251 SUMA_RETURN (NULL);
03252 }
03253 break;
03254 }
03255
03256 case SUMA_CMAP_GRAY02:
03257 {
03258 Fiducials = (float **)SUMA_allocate2D(2, 3, sizeof(float));
03259 if (!Fiducials) {
03260 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials.\n", FuncName);
03261 SUMA_RETURN (NULL);
03262 }
03263
03264 k = 0;
03265 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.4; ++k;
03266 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.7; ++k;
03267
03268
03269 CM = SUMA_MakeColorMap (Fiducials, k, 2, NOPE, SUMA_StandardMapName(mapcode,&nc));
03270
03271 SUMA_free2D((char **)Fiducials, k);
03272
03273 if (!CM) {
03274 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03275 SUMA_RETURN (NULL);
03276 }
03277 break;
03278 }
03279
03280 case SUMA_CMAP_flpGRAY02:
03281 {
03282 Fiducials = (float **)SUMA_allocate2D(2, 3, sizeof(float));
03283 if (!Fiducials) {
03284 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials.\n", FuncName);
03285 SUMA_RETURN (NULL);
03286 }
03287
03288 k = 0;
03289 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.7; ++k;
03290 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.4; ++k;
03291
03292
03293 CM = SUMA_MakeColorMap (Fiducials, k, 2, NOPE, SUMA_StandardMapName(mapcode,&nc));
03294
03295 SUMA_free2D((char **)Fiducials, k);
03296
03297 if (!CM) {
03298 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03299 SUMA_RETURN (NULL);
03300 }
03301 break;
03302 }
03303 case SUMA_CMAP_GRAY20:
03304 {
03305 Fiducials = (float **)SUMA_allocate2D(2, 3, sizeof(float));
03306 if (!Fiducials) {
03307 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials.\n", FuncName);
03308 SUMA_RETURN (NULL);
03309 }
03310
03311 k = 0;
03312 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.3; ++k;
03313 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.8; ++k;
03314
03315
03316 CM = SUMA_MakeColorMap (Fiducials, k, 20, NOPE, SUMA_StandardMapName(mapcode,&nc));
03317
03318 SUMA_free2D((char **)Fiducials, k);
03319
03320 if (!CM) {
03321 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03322 SUMA_RETURN (NULL);
03323 }
03324 break;
03325 }
03326
03327 case SUMA_CMAP_nGRAY20:
03328 {
03329 Fiducials = (float **)SUMA_allocate2D(2, 3, sizeof(float));
03330 if (!Fiducials) {
03331 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials.\n", FuncName);
03332 SUMA_RETURN (NULL);
03333 }
03334
03335 k = 0;
03336 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.3; ++k;
03337 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.8; ++k;
03338
03339
03340 CM = SUMA_MakeColorMap (Fiducials, k, 20, NOPE, SUMA_StandardMapName(mapcode,&nc));
03341
03342 SUMA_free2D((char **)Fiducials, k);
03343
03344 if (!CM) {
03345 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03346 SUMA_RETURN (NULL);
03347 }
03348 break;
03349 }
03350
03351 case SUMA_CMAP_BW20:
03352 {
03353 Fiducials = (float **)SUMA_allocate2D(2, 3, sizeof(float));
03354 if (!Fiducials) {
03355 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials.\n", FuncName);
03356 SUMA_RETURN (NULL);
03357 }
03358
03359 k = 0;
03360 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.0; ++k;
03361 Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 1.0; ++k;
03362
03363
03364 CM = SUMA_MakeColorMap (Fiducials, k, 20, NOPE, SUMA_StandardMapName(mapcode,&nc));
03365
03366 SUMA_free2D((char **)Fiducials, k);
03367
03368 if (!CM) {
03369 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03370 SUMA_RETURN (NULL);
03371 }
03372 break;
03373 }
03374 case SUMA_CMAP_MATLAB_DEF_BYR64:
03375 {
03376
03377 Ncols = 64;
03378 NFid = 10;
03379
03380 Fiducials = (float **)SUMA_allocate2D(NFid, 3, sizeof(float));
03381 Nind = (int *) SUMA_calloc (NFid, sizeof (int));
03382
03383 if (!Fiducials || !Nind) {
03384 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials or Nind.\n", FuncName);
03385 SUMA_RETURN (NULL);
03386 }
03387
03388
03389 k = 0;
03390 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.5625; Nind[k] = 0; ++k;
03391 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 1.0; Nind[k] = 7; ++k;
03392 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.5; Fiducials[k][2] = 1.0; Nind[k] = 15; ++k;
03393 Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 1.0; Nind[k] = 23; ++k;
03394 Fiducials[k][0] = 0.5; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.5625; Nind[k] = 31; ++k;
03395 Fiducials[k][0] = 0.5625; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.5; Nind[k] = 32; ++k;
03396 Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; Nind[k] = 40; ++k;
03397 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.5; Fiducials[k][2] = 0.0; Nind[k] = 48; ++k;
03398 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; Nind[k] = 56; ++k;
03399 Fiducials[k][0] = 0.5625; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; Nind[k] = 63; ++k;
03400
03401
03402 CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03403
03404
03405 SUMA_free2D((char **)Fiducials, k);
03406 SUMA_free(Nind);
03407
03408 if (!CM) {
03409 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03410 SUMA_RETURN (NULL);
03411 }
03412 break;
03413
03414 }
03415
03416 case SUMA_CMAP_BGYR64:
03417 {
03418
03419 Ncols = 64;
03420 NFid = 10;
03421
03422 Fiducials = (float **)SUMA_allocate2D(NFid, 3, sizeof(float));
03423 Nind = (int *) SUMA_calloc (NFid, sizeof (int));
03424
03425 if (!Fiducials || !Nind) {
03426 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials or Nind.\n", FuncName);
03427 SUMA_RETURN (NULL);
03428 }
03429
03430
03431 k = 0;
03432 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.5625; Nind[k] = 0; ++k;
03433 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 1.0; Nind[k] = 7; ++k;
03434 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.5; Fiducials[k][2] = 1.0; Nind[k] = 15; ++k;
03435 Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 1.0; Nind[k] = 18; ++k;
03436 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.5; Fiducials[k][2] = 0.0; Nind[k] = 24; ++k;
03437 Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; Nind[k] = 32; ++k;
03438 Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; Nind[k] = 43; ++k;
03439 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.5; Fiducials[k][2] = 0.0; Nind[k] = 48; ++k;
03440 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; Nind[k] = 56; ++k;
03441 Fiducials[k][0] = 0.5625; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; Nind[k] = 63; ++k;
03442
03443
03444 CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03445
03446
03447 SUMA_free2D((char **)Fiducials, k);
03448 SUMA_free(Nind);
03449
03450 if (!CM) {
03451 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03452 SUMA_RETURN (NULL);
03453 }
03454 break;
03455
03456 }
03457 case SUMA_CMAP_ROI256:
03458 {
03459
03460 Ncols = 256;
03461 NFid = 6;
03462
03463 Fiducials = (float **)SUMA_allocate2D(NFid, 3, sizeof(float));
03464 Nind = (int *) SUMA_calloc (NFid, sizeof (int));
03465
03466 if (!Fiducials || !Nind) {
03467 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials or Nind.\n", FuncName);
03468 SUMA_RETURN (NULL);
03469 }
03470
03471
03472 k = 0;
03473 Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0; Nind[k] = 0; ++k;
03474 Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0; Nind[k] = 50; ++k;
03475 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0; Fiducials[k][2] = 1.0; Nind[k] = 100; ++k;
03476 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; Nind[k] = 150; ++k;
03477 Fiducials[k][0] = 0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 1; Nind[k] = 200; ++k;
03478 Fiducials[k][0] = 1; Fiducials[k][1] = 0; Fiducials[k][2] = 1; Nind[k] = 255; ++k;
03479
03480
03481
03482 CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03483
03484
03485 SUMA_free2D((char **)Fiducials, k);
03486 SUMA_free(Nind);
03487
03488 if (!CM) {
03489 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03490 SUMA_RETURN (NULL);
03491 }
03492 break;
03493
03494 }
03495
03496
03497 case SUMA_CMAP_ROI128:
03498 {
03499
03500 Ncols = 128;
03501 NFid = 6;
03502
03503 Fiducials = (float **)SUMA_allocate2D(NFid, 3, sizeof(float));
03504 Nind = (int *) SUMA_calloc (NFid, sizeof (int));
03505
03506 if (!Fiducials || !Nind) {
03507 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials or Nind.\n", FuncName);
03508 SUMA_RETURN (NULL);
03509 }
03510
03511
03512 k = 0;
03513 Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0; Nind[k] = 0; ++k;
03514 Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0; Nind[k] = 25; ++k;
03515 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0; Fiducials[k][2] = 1.0; Nind[k] = 50; ++k;
03516 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; Nind[k] = 75; ++k;
03517 Fiducials[k][0] = 0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 1; Nind[k] = 100; ++k;
03518 Fiducials[k][0] = 1; Fiducials[k][1] = 0; Fiducials[k][2] = 1; Nind[k] = 127; ++k;
03519
03520
03521
03522 CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03523
03524
03525 SUMA_free2D((char **)Fiducials, k);
03526 SUMA_free(Nind);
03527
03528 if (!CM) {
03529 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03530 SUMA_RETURN (NULL);
03531 }
03532 break;
03533
03534 }
03535
03536 case SUMA_CMAP_ROI64:
03537 {
03538
03539 Ncols = 64;
03540 NFid = 6;
03541
03542 Fiducials = (float **)SUMA_allocate2D(NFid, 3, sizeof(float));
03543 Nind = (int *) SUMA_calloc (NFid, sizeof (int));
03544
03545 if (!Fiducials || !Nind) {
03546 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for Fiducials or Nind.\n", FuncName);
03547 SUMA_RETURN (NULL);
03548 }
03549
03550
03551 k = 0;
03552 Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0; Nind[k] = 0; ++k;
03553 Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0; Nind[k] = 12; ++k;
03554 Fiducials[k][0] = 0.0; Fiducials[k][1] = 0; Fiducials[k][2] = 1.0; Nind[k] = 25; ++k;
03555 Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; Nind[k] = 33; ++k;
03556 Fiducials[k][0] = 0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 1; Nind[k] = 50; ++k;
03557 Fiducials[k][0] = 1; Fiducials[k][1] = 0; Fiducials[k][2] = 1; Nind[k] = 63; ++k;
03558
03559
03560
03561 CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03562
03563
03564 SUMA_free2D((char **)Fiducials, k);
03565 SUMA_free(Nind);
03566
03567 if (!CM) {
03568 fprintf (SUMA_STDERR,"Error %s: Failed to create CM.\n", FuncName);
03569 SUMA_RETURN (NULL);
03570 }
03571 break;
03572
03573 }
03574
03575 default:
03576 fprintf (SUMA_STDERR,"Error %s: Unrecognized color map name.\n", FuncName);
03577 SUMA_RETURN (NULL);
03578
03579 }
03580
03581 SUMA_RETURN (CM);
03582 }
03583
03584 #ifdef SUMA_ScaleToMap_STAND_ALONE
03585 void SUMA_ScaleToMap_usage ()
03586 {
03587 static char FuncName[]={"SUMA_ScaleToMap_usage"};
03588 char * s = NULL;
03589 s = SUMA_help_basics();
03590 fprintf (SUMA_STDOUT, "\nUsage: ScaleToMap <-input IntFile icol vcol> \n"
03591 " [-cmap MapType] [-cmapfile Mapfile] [-cmapdb Palfile] [-frf] \n"
03592 " [-clp/-perc_clp clp0 clp1] [-apr/-anr range]\n"
03593 " [-interp/-nointerp/-direct] [-msk msk0 msk1] [-nomsk_col]\n"
03594 " [-msk_col R G B] [-br BrightFact]\n"
03595 " [-h/-help] [-verb] [-showmap] [-showdb]\n"
03596 "\n"
03597 " -input IntFile icol vcol: input data.\n"
03598 " Infile: 1D formatted ascii file containing node values\n"
03599 " icol: index of node index column \n"
03600 " (-1 if the node index is implicit)\n"
03601 " vcol: index of node value column.\n"
03602 " Example: -input ValOnly.1D -1 0 \n"
03603 " for a 1D file containing node values\n"
03604 " in the first column and no node indices.\n"
03605 " Example: -input NodeVal.1D 1 3\n"
03606 " for a 1D file containing node indices in\n"
03607 " the SECOND column and node values in the \n"
03608 " FOURTH column (index counting begins at 0)\n"
03609 " -v and -iv options are now obsolete.\n"
03610 " Use -input option instead.\n"
03611 " -cmap MapName: (optional, default RGYBR20) \n"
03612 " choose one of the standard colormaps available with SUMA:\n"
03613 " RGYBR20, BGYR19, BW20, GRAY20, MATLAB_DEF_BYR64, \n"
03614 " ROI64, ROI128\n"
03615 " You can also use AFNI's default paned color maps:\n"
03616 " The maps are labeled according to the number of \n"
03617 " panes and their sign. Example: afni_p10\n"
03618 " uses the positive 10-pane afni colormap.\n"
03619 " afni_n10 is the negative counterpart.\n"
03620 " These maps are meant to be used with\n"
03621 " the options -apr and -anr listed below.\n"
03622 " You can also load non-default AFNI colormaps\n"
03623 " from .pal files (AFNI's colormap format); see option\n"
03624 " -cmapdb below.\n"
03625 " -cmapdb Palfile: read color maps from AFNI .pal file\n"
03626 " In addition to the default paned AFNI colormaps, you\n"
03627 " can load colormaps from a .pal file.\n"
03628 " To access maps in the Palfile you must use the -cmap option\n"
03629 " with the label formed by the name of the palette, its sign\n"
03630 " and the number of panes. For example, to following palette:\n"
03631 " ***PALETTES deco [13]\n"
03632 " should be accessed with -cmap deco_n13\n"
03633 " ***PALETTES deco [13+]\n"
03634 " should be accessed with -cmap deco_p13\n"
03635 " -cmapfile Mapfile: read color map from Mapfile.\n"
03636 " Mapfile:1D formatted ascii file containing colormap.\n"
03637 " each row defines a color in one of two ways:\n"
03638 " R G B or\n"
03639 " R G B f \n"
03640 " where R, G, B specify the red, green and blue values, \n"
03641 " between 0 and 1 and f specifies the fraction of the range\n"
03642 " reached at this color. THINK values of right of AFNI colorbar.\n"
03643 " The use of fractions (it is optional) would allow you to create\n"
03644 " non-linear color maps where colors cover differing fractions of \n"
03645 " the data range.\n"
03646 " Sample colormap with positive range only (a la AFNI):\n"
03647 " 0 0 1 1.0\n"
03648 " 0 1 0 0.8\n"
03649 " 1 0 0 0.6\n"
03650 " 1 1 0 0.4\n"
03651 " 0 1 1 0.2\n"
03652 " Note the order in which the colors and fractions are specified.\n"
03653 " The bottom color of the +ve colormap should be at the bottom of the\n"
03654 " file and have the lowest +ve fraction. The fractions here define a\n"
03655 " a linear map so they are not necessary but they illustrate the format\n"
03656 " of the colormaps.\n"
03657 " Comparable colormap with negative range included:\n"
03658 " 0 0 1 1.0\n"
03659 " 0 1 0 0.6\n"
03660 " 1 0 0 0.2\n"
03661 " 1 1 0 -0.2\n"
03662 " 0 1 1 -0.6\n"
03663 " The bottom color of the -ve colormap should have the \n"
03664 " lowest -ve fraction. \n"
03665 " You can use -1 -1 -1 for a color to indicate a no color\n"
03666 " (like the 'none' color in AFNI). Values mapped to this\n"
03667 " 'no color' will be masked as with the -msk option.\n"
03668 " If your 1D color file has more than three or 4 columns,\n"
03669 " you can use the [] convention adopted by AFNI programs\n"
03670 " to select the columns you need.\n"
03671 " -frf: (optional) first row in file is the first color.\n"
03672 " As explained in the -cmapfile option above, the first \n"
03673 " or bottom (indexed 0 )color of the colormap should be \n"
03674 " at the bottom of the file. If the opposite is true, use\n"
03675 " the -frf option to signal that.\n"
03676 " This option is only useful with -cmapfile.\n"
03677 " -clp/-perc_clp clp0 clp1: (optional, default no clipping)\n"
03678 " clips values in IntVect. if -clp is used then values in vcol\n"
03679 " < clp0 are clipped to clp0 and > clp1 are clipped to clp1\n"
03680 " if -perc_clp is used them vcol is clipped to the values \n"
03681 " corresponding to clp0 and clp1 percentile.\n"
03682 " The -clp/-prec_clp options are mutually exclusive with -apr/-anr.\n"
03683 " -apr range: (optional) clips the values in IntVect to [0 range].\n"
03684 " This option allows range of colormap to be set as in AFNI, \n"
03685 " with Positive colorbar (Pos selected).\n"
03686 " This option is mutually exclusive with -clp/-perc_clp).\n"
03687 " set range = 0 for autoranging.\n"
03688 " If you use -apr and your colormap contains fractions, you\n"
03689 " must use a positive range colormap.\n"
03690 " -anr range: (optional) clips the values in IntVect to [-range range].\n"
03691 " This option allows range of colormap to be set as in AFNI, \n"
03692 " with Negative colorbar (Pos NOT selected).\n"
03693 " This option is mutually exclusive with -clp/-perc_clp).\n"
03694 " set range = 0 for autoranging.\n"
03695 " If you use -anr and your colormap contains fractions, you\n"
03696 " must use a negative range colormap.\n"
03697 " -interp: (default) use color interpolation between colors in colormap\n"
03698 " If a value is assigned between two colors on the colorbar,\n"
03699 " it receives a color that is an interpolation between those two colors.\n"
03700 " This is the default behaviour in SUMA and AFNI when using the continuous\n"
03701 " colorscale. Mutually exclusive with -nointerp and -direct options.\n"
03702 " -nointerp: (optional) turns off color interpolation within the colormap\n"
03703 " Color assigniment is done a la AFNI when the paned colormaps are used.\n"
03704 " Mutually exclusive with -interp and -direct options.\n"
03705 " -direct: (optional) values (typecast to integers) are mapped directly\n"
03706 " to index of color in color maps. Example: value 4 is assigned\n"
03707 " to the 5th (index 4) color in the color map (same for values\n"
03708 " 4.2 and 4.7). This mapping scheme is useful for ROI indexed type\n"
03709 " data. Negative data values are set to 0 and values >= N_col \n"
03710 " (the number of colors in the colormap) are set to N_col -1\n"
03711 " -msk_zero: (optional) values that are 0 will get masked no matter\n"
03712 " what colormaps or mapping schemes you are using. \n"
03713 " AFNI masks all zero values by default.\n"
03714 " -msk msk0 msk1: (optinal, default is no masking) \n"
03715 " Values in vcol (BEFORE clipping is performed) \n"
03716 " between [msk0 msk1] are masked by the masking color.\n"
03717 " -msk_col R G B: (optional, default is 0.3 0.3 0.3) \n"
03718 " Sets the color of masked voxels.\n"
03719 " -nomsk_col: do not output nodes that got masked.\n"
03720 " It does not make sense to use this option with\n"
03721 " -msk_col.\n"
03722 " -br BrightFact: (optional, default is 1) \n"
03723 " Applies a brightness factor to the colors \n"
03724 " of the colormap and the mask color.\n"
03725 " -h or -help: displays this help message.\n"
03726 "\n"
03727 " The following options are for debugging and sanity checks.\n"
03728 " -verb: (optional) verbose mode.\n"
03729 " -showmap: (optional) print the colormap to the screen and quit.\n"
03730 " This option is for debugging and sanity checks.\n"
03731 " -showdb: (optional) print the colors and colormaps of AFNI\n"
03732 " along with any loaded from the file Palfile.\n"
03733 "%s"
03734 "\n", s);
03735 SUMA_free(s); s = NULL;
03736 s = SUMA_New_Additions(0, 1); printf("%s\n", s);SUMA_free(s); s = NULL;
03737 fprintf (SUMA_STDOUT, " Ziad S. Saad SSCC/NIMH/NIH ziad@nih.gov \n"
03738 " July 31/02 \n"
03739 "\n");
03740 }
03741
03742 int main (int argc,char *argv[])
03743 {
03744 static char FuncName[]={"ScaleToMap"};
03745 char *IntName = NULL, *Prfx, h[9], *CmapFileName = NULL, *dbfile = NULL, *MapName=NULL;
03746 MRI_IMAGE *im = NULL;
03747 float *far=NULL;
03748 int N_V, N_Int, kar, k, ii, i, icol=-1, vcol=-1, Sgn, interpmode, k3;
03749 int Vminloc, Vmaxloc, *iV = NULL;
03750 float Vmin, Vmax, brfact;
03751 float *V = NULL, *Vsort = NULL;
03752 float IntRange[2], MaskColor[3], MaskRange[2], arange;
03753 SUMA_Boolean ApplyClip, ApplyMask, setMaskCol, ApplyPercClip, Vopt;
03754 SUMA_Boolean iVopt, inopt, NoMaskCol, MapSpecified, alaAFNI, MaskZero;
03755 SUMA_Boolean brk, frf, ShowMap, ShowMapdb;
03756 SUMA_COLOR_MAP *CM;
03757 SUMA_SCALE_TO_MAP_OPT * OptScl;
03758 SUMA_STANDARD_CMAP MapType;
03759 SUMA_COLOR_SCALED_VECT * SV;
03760 SUMA_AFNI_COLORS *SAC=NULL;
03761 SUMA_Boolean FromAFNI = NOPE;
03762 int imap, isPmap, isNmap;
03763 SUMA_Boolean LocalHead = NOPE;
03764
03765 SUMA_mainENTRY;
03766
03767 #if 0
03768
03769 SUMAg_CF = SUMA_Create_CommonFields ();
03770 if (SUMAg_CF == NULL) {
03771 fprintf(SUMA_STDERR,"Error %s: Failed in SUMA_Create_CommonFields\n", FuncName);
03772 exit(1);
03773 }
03774 SUMAg_CF->isGraphical = YUP;
03775
03776 SUMAg_CF->scm = SUMA_Build_Color_maps();
03777 if (!SUMAg_CF->scm) {
03778 SUMA_SL_Err("Failed to build color maps.\n");
03779 exit(1);
03780 }
03781 SUMA_INOUT_NOTIFY_OFF;
03782 #else
03783 SUMA_STANDALONE_INIT;
03784 #endif
03785
03786
03787
03788
03789
03790
03791
03792
03793
03794 kar = 1;
03795 brfact = 1;
03796 MaskColor[0] = MaskColor[1] = MaskColor[2] = 0.3;
03797 ApplyClip = NOPE;
03798 ApplyPercClip = NOPE;
03799 ApplyMask = NOPE;
03800 NoMaskCol = NOPE;
03801 MaskZero = NOPE;
03802 setMaskCol = NOPE;
03803 Vopt = NOPE;
03804 iVopt = NOPE;
03805 inopt = NOPE;
03806 MapType = SUMA_CMAP_RGYBR20;
03807 brk = NOPE;
03808 MapSpecified = NOPE;
03809 CmapFileName = NULL;
03810 interpmode = SUMA_UNDEFINED_MODE;
03811 ShowMap = NOPE;
03812 alaAFNI = NOPE;
03813 frf = NOPE;
03814 arange = -1.0;
03815 Sgn = 0;
03816 ShowMapdb = NOPE;
03817 while (kar < argc) {
03818
03819 if (strcmp(argv[kar], "-h") == 0 || strcmp(argv[kar], "-help") == 0) {
03820 SUMA_ScaleToMap_usage();
03821 exit (1);
03822 }
03823
03824 SUMA_SKIP_COMMON_OPTIONS(brk, kar);
03825
03826 if (!brk && strcmp(argv[kar], "-verb") == 0) {
03827 LocalHead = NOPE;
03828 brk = YUP;
03829 }
03830
03831 if (!brk && strcmp(argv[kar], "-ionot") == 0) {
03832 SUMA_SL_Err("-ionot is obsolete. \n"
03833 "Use -trace option.");
03834 exit (1);
03835 SUMA_INOUT_NOTIFY_ON;
03836 brk = YUP;
03837 }
03838
03839 if (!brk && strcmp(argv[kar], "-msk_zero") == 0) {
03840 MaskZero = YUP;
03841 brk = YUP;
03842 }
03843
03844 if (!brk && (strcmp(argv[kar], "-input") == 0)) {
03845 kar ++;
03846 if (kar+2 >= argc) {
03847 fprintf (SUMA_STDERR, "need 3 arguments after -input \n");
03848 exit (1);
03849 }
03850 IntName = argv[kar]; kar ++;
03851 icol = atoi(argv[kar]); kar ++;
03852 vcol = atoi(argv[kar]);
03853 inopt = YUP;
03854 brk = YUP;
03855 }
03856
03857 if (!brk && (strcmp(argv[kar], "-apr") == 0)) {
03858 if (arange >= 0) {
03859 fprintf (SUMA_STDERR, "range has already been specified.\n");
03860 exit (1);
03861 }
03862 kar ++;
03863 if (kar >= argc) {
03864 fprintf (SUMA_STDERR, "need argument after -apr \n");
03865 exit (1);
03866 }
03867 arange = atof(argv[kar]);
03868 if (arange < 0) {
03869 fprintf (SUMA_STDERR, "range must be positive.\n");
03870 exit (1);
03871 }
03872 Sgn = 1;
03873 alaAFNI = YUP;
03874 brk = YUP;
03875 }
03876
03877 if (!brk && (strcmp(argv[kar], "-anr") == 0)) {
03878 if (arange >= 0) {
03879 fprintf (SUMA_STDERR, "range has already been specified.\n");
03880 exit (1);
03881 }
03882 kar ++;
03883 if (kar >= argc) {
03884 fprintf (SUMA_STDERR, "need argument after -anr \n");
03885 exit (1);
03886 }
03887 arange = atof(argv[kar]);
03888 if (arange < 0) {
03889 fprintf (SUMA_STDERR, "range must be positive.\n");
03890 exit (1);
03891 }
03892
03893 Sgn = -1;
03894 alaAFNI = YUP;
03895 brk = YUP;
03896 }
03897
03898 if (!brk && (strcmp(argv[kar], "-v") == 0)) {
03899 fprintf (SUMA_STDERR, "\n -v option is now obsolete.\nUse -input option instead.\n");
03900 exit (1);
03901 kar ++;
03902 if (kar >= argc) {
03903 fprintf (SUMA_STDERR, "need argument after -v \n");
03904 exit (1);
03905 }
03906 IntName = argv[kar];
03907 Vopt = YUP;
03908 brk = YUP;
03909 }
03910
03911 if (!brk && (strcmp(argv[kar], "-iv") == 0)) {
03912 fprintf (SUMA_STDERR, "\n -iv option is now obsolete.\nUse -input option instead.\n");
03913 exit (1);
03914 kar ++;
03915 if (kar >= argc) {
03916 fprintf (SUMA_STDERR, "need argument after -iv \n");
03917 exit (1);
03918 }
03919 IntName = argv[kar];
03920 iVopt = YUP;
03921 brk = YUP;
03922 }
03923
03924 if (!brk && (strcmp(argv[kar], "-br") == 0)) {
03925 kar ++;
03926 if (kar >= argc) {
03927 fprintf (SUMA_STDERR, "need argument after -br \n");
03928 exit (1);
03929 }
03930 brfact = atof(argv[kar]);
03931
03932 brk = YUP;
03933 }
03934
03935 if (!brk && (strcmp(argv[kar], "-frf") == 0)) {
03936 frf = YUP;
03937 brk = YUP;
03938 }
03939
03940 if (!brk && (strcmp(argv[kar], "-showmap") == 0)) {
03941 ShowMap = YUP;
03942 brk = YUP;
03943 }
03944
03945 if (!brk && (strcmp(argv[kar], "-showdb") == 0)) {
03946 ShowMapdb = YUP;
03947 brk = YUP;
03948 }
03949
03950 if (!brk && (strcmp(argv[kar], "-nointerp") == 0)) {
03951 if (interpmode != SUMA_UNDEFINED_MODE) {
03952 fprintf (SUMA_STDERR, "Color interpolation mode already set.\n");
03953 }
03954 interpmode = SUMA_NO_INTERP;
03955 brk = YUP;
03956 }
03957
03958 if (!brk && (strcmp(argv[kar], "-direct") == 0)) {
03959 if (interpmode != SUMA_UNDEFINED_MODE) {
03960 fprintf (SUMA_STDERR, "Color interpolation mode already set.\n");
03961 }
03962 interpmode = SUMA_DIRECT;
03963 brk = YUP;
03964 }
03965
03966 if (!brk && (strcmp(argv[kar], "-interp") == 0)) {
03967 if (interpmode != SUMA_UNDEFINED_MODE) {
03968 fprintf (SUMA_STDERR, "Color interpolation mode already set.\n(-nointerp, -direct and -interp are mutually exclusive.\n");
03969 }
03970 interpmode = SUMA_INTERP;
03971 brk = YUP;
03972 }
03973
03974 if (!brk && (strcmp(argv[kar], "-clp") == 0)) {
03975 kar ++;
03976 if (kar+1 >= argc) {
03977 fprintf (SUMA_STDERR, "need 2 arguments after -clp \n");
03978 exit (1);
03979 }
03980 ApplyClip = YUP;
03981 IntRange[0] = atof(argv[kar]); kar ++;
03982 IntRange[1] = atof(argv[kar]);
03983 brk = YUP;
03984 }
03985
03986 if (!brk && (strcmp(argv[kar], "-perc_clp") == 0)) {
03987 kar ++;
03988 if (kar+1 >= argc) {
03989 fprintf (SUMA_STDERR, "need 2 arguments after -perc_clp ");
03990 exit (1);
03991 }
03992 ApplyPercClip = YUP;
03993 IntRange[0] = atof(argv[kar]); kar ++;
03994 IntRange[1] = atof(argv[kar]);
03995 brk = YUP;
03996 }
03997
03998 if (!brk && (strcmp(argv[kar], "-msk") == 0)) {
03999 kar ++;
04000 if (kar+1 >= argc) {
04001 fprintf (SUMA_STDERR, "need 2 arguments after -msk ");
04002 exit (1);
04003 }
04004 ApplyMask = YUP;
04005 MaskRange[0] = atof(argv[kar]); kar ++;
04006 MaskRange[1] = atof(argv[kar]);
04007 brk = YUP;
04008 }
04009
04010 if (!brk && (strcmp(argv[kar], "-nomsk_col") == 0)) {
04011 NoMaskCol = YUP;
04012 brk = YUP;
04013 }
04014
04015 if (!brk && (strcmp(argv[kar], "-msk_col") == 0)) {
04016 kar ++;
04017 if (kar+2 >= argc) {
04018 fprintf (SUMA_STDERR, "need 3 arguments after -msk_col ");
04019 exit (1);
04020 }
04021 setMaskCol = YUP;
04022 MaskColor[0] = atof(argv[kar]); kar ++;
04023 MaskColor[1] = atof(argv[kar]); kar ++;
04024 MaskColor[2] = atof(argv[kar]);
04025 brk = YUP;
04026 }
04027
04028 if (!brk && (strcmp(argv[kar], "-cmapfile") ==0)) {
04029 if (MapSpecified) {
04030 fprintf (SUMA_STDERR, "Color map already specified.\n-cmap and -cmapfile are mutually exclusive\n");
04031 exit (1);
04032 }
04033 MapSpecified = YUP;
04034 kar ++;
04035 if (kar >= argc) {
04036 fprintf (SUMA_STDERR, "need 1 arguments after -cmapfile ");
04037 exit (1);
04038 }
04039
04040 CmapFileName = argv[kar];
04041 brk = YUP;
04042 }
04043
04044 if (!brk && (strcmp(argv[kar], "-cmapdb") ==0)) {
04045 kar ++;
04046 if (kar >= argc) {
04047 fprintf (SUMA_STDERR, "need 1 arguments after -cmapdb ");
04048 exit (1);
04049 }
04050
04051 dbfile = argv[kar];
04052 brk = YUP;
04053 }
04054
04055
04056 if (!brk && (strcmp(argv[kar], "-cmap") ==0)) {
04057 if (MapSpecified) {
04058 fprintf (SUMA_STDERR, "Color map already specified.\n-cmap and -cmapfile are mutually exclusive\n");
04059 exit (1);
04060 }
04061 MapSpecified = YUP;
04062 kar ++;
04063 if (kar >= argc) {
04064 fprintf (SUMA_STDERR, "need 1 arguments after -cmap ");
04065 exit (1);
04066 }
04067 MapName = argv[kar];
04068 MapType = SUMA_CMAP_UNDEFINED;
04069 if (strcmp(argv[kar], "RYGBR20") == 0) MapType = SUMA_CMAP_RGYBR20;
04070 if (strcmp(argv[kar], "BW20") == 0) MapType = SUMA_CMAP_BW20;
04071 if (strcmp(argv[kar], "GRAY02") == 0) MapType = SUMA_CMAP_GRAY02;
04072 if (strcmp(argv[kar], "flpGRAY02") == 0) MapType = SUMA_CMAP_flpGRAY02;
04073 if (strcmp(argv[kar], "GRAY20") == 0) MapType = SUMA_CMAP_GRAY20;
04074 if (strcmp(argv[kar], "BGYR19") == 0) MapType = SUMA_CMAP_BGYR19;
04075 if (strcmp(argv[kar], "MATLAB_DEF_BYR64") == 0) MapType = SUMA_CMAP_MATLAB_DEF_BYR64;
04076 if (strcmp(argv[kar], "BGYR64") == 0) MapType = SUMA_CMAP_BGYR64;
04077 if (strcmp(argv[kar], "ROI64") == 0) MapType = SUMA_CMAP_ROI64;
04078 if (strcmp(argv[kar], "ROI128") == 0) MapType = SUMA_CMAP_ROI128;
04079 if (strcmp(argv[kar], "ROI256") == 0) MapType = SUMA_CMAP_ROI256;
04080
04081 if (MapType == SUMA_CMAP_UNDEFINED) {
04082
04083
04084
04085
04086 }
04087 brk = YUP;
04088 }
04089
04090 if (!brk) {
04091 fprintf (SUMA_STDERR,"Error %s: Option %s not understood. Try -help for usage\n", FuncName, argv[kar]);
04092 exit (1);
04093 } else {
04094 brk = NOPE;
04095 kar ++;
04096 }
04097
04098 }
04099
04100
04101 #if 0
04102
04103
04104 SAC = SUMA_Get_AFNI_Default_Color_Maps ();
04105 if (!SAC) {
04106 fprintf (SUMA_STDERR,"Error %s: Failed to obtain AFNI's standard colors.\n", FuncName);
04107 exit(1);
04108 } else {
04109
04110 if (dbfile) {
04111 SUMA_LH("Now trying to read db file");
04112 if (SUMA_AFNI_Extract_Colors ( dbfile, SAC ) < 0) {
04113 fprintf (SUMA_STDERR,"Error %s: Failed to read %s colormap file.\n", FuncName, dbfile);
04114 exit(1);
04115 }
04116 }
04117 }
04118 #else
04119 if (!SUMAg_CF->scm) {
04120 SUMAg_CF->scm = SUMA_Build_Color_maps();
04121 if (!SUMAg_CF->scm) {
04122 SUMA_SL_Err("Failed to build color maps.\n");
04123 exit(1);
04124 }
04125 }
04126
04127 SAC = SUMAg_CF->scm;
04128
04129 if (dbfile) {
04130 SUMA_LH("Now trying to read db file");
04131 if (SUMA_AFNI_Extract_Colors ( dbfile, SAC ) < 0) {
04132 fprintf (SUMA_STDERR,"Error %s: Failed to read %s colormap file.\n", FuncName, dbfile);
04133 exit(1);
04134 }
04135 }
04136 #endif
04137
04138 FromAFNI = NOPE;
04139 if (CmapFileName) {
04140
04141 CM = SUMA_Read_Color_Map_1D (CmapFileName);
04142 if (CM == NULL) {
04143 fprintf (SUMA_STDERR,"Error %s: Could not load colormap.\n", FuncName);
04144 exit (1);
04145 }
04146 if (frf) {
04147 SUMA_LH("Flipping colormap");
04148 SUMA_Flip_Color_Map (CM);
04149 }
04150
04151 if (!CM->Sgn) CM->Sgn = Sgn;
04152 }else{
04153
04154 if (MapType != SUMA_CMAP_UNDEFINED) {
04155 CM = SUMA_GetStandardMap (MapType);
04156 if (CM) {
04157
04158 CM->Sgn = Sgn;
04159 } else {
04160 fprintf (SUMA_STDERR,"Error %s: Could not get standard colormap.\n", FuncName);
04161 exit (1);
04162 }
04163 } else {
04164 SUMA_LH("An AFNI color map ");
04165
04166 FromAFNI = YUP;
04167 imap = SUMA_Find_ColorMap ( MapName, SAC->CMv, SAC->N_maps, -2);
04168 if (imap < 0) {
04169 fprintf (SUMA_STDERR,"Error %s: Could not find colormap %s.\n", FuncName, MapName);
04170 exit (1);
04171 }
04172 CM = SAC->CMv[imap];
04173 }
04174 }
04175
04176
04177
04178 if (ShowMap) {
04179 fprintf (SUMA_STDERR, "%s: Colormap used:\n", FuncName);
04180 SUMA_Show_ColorMapVec (&CM, 1, NULL, 2);
04181 {
04182 SUMA_SurfaceObject *SO = NULL;
04183 float orig[3] = { SUMA_CMAP_ORIGIN };
04184 float topright[3] = { SUMA_CMAP_TOPLEFT };
04185
04186 SUMA_SL_Note("JUST FOR TESTING");
04187 SO = SUMA_Cmap_To_SO (CM, orig, topright, 2);
04188 SUMA_SL_Note("Cleanup");
04189 if (SO) SUMA_Free_Surface_Object(SO);
04190 }
04191 exit(0);
04192 }
04193
04194
04195 if (ShowMapdb) {
04196 fprintf (SUMA_STDERR, "%s: AFNI colormaps found in db:\n", FuncName);
04197 SUMA_Show_ColorVec (SAC->Cv, SAC->N_cols, NULL);
04198 SUMA_Show_ColorMapVec (SAC->CMv, SAC->N_maps, NULL, 2);
04199 exit(0);
04200 }
04201
04202
04203 if (!IntName) {
04204 fprintf (SUMA_STDERR,"Error %s: No input file specified.\n", FuncName);
04205 exit(1);
04206 }
04207
04208
04209 if (interpmode == SUMA_UNDEFINED_MODE) interpmode = SUMA_INTERP;
04210
04211
04212 if (!SUMA_filexists (IntName)) {
04213 fprintf (SUMA_STDERR,"Error %s: File %s could not be found.\n", FuncName, IntName);
04214 exit(1);
04215 }
04216
04217 if (frf && !CmapFileName) {
04218 fprintf (SUMA_STDERR,"Error %s: -frf option is only valid with -cmapfile.\n", FuncName);
04219 exit(1);
04220 }
04221
04222 if (ApplyPercClip && ApplyClip) {
04223 fprintf (SUMA_STDERR,"Error %s: Simultaneous use of -clp and -perc_clp. You should be punished.\n", FuncName);
04224 exit(1);
04225 }
04226
04227 if ((ApplyPercClip || ApplyClip) && arange >= 0.0) {
04228 fprintf (SUMA_STDERR,"Error %s: Simultaneous use of -clp/-perc_clp and -apr/anr.\n Read the help.\n", FuncName);
04229 exit(1);
04230 }
04231
04232 if (iVopt || Vopt) {
04233 fprintf (SUMA_STDERR,"Error %s: -v and -iv are obsolete.\n Use -input option instead.\n", FuncName);
04234 exit(1);
04235 }
04236
04237 if (!inopt) {
04238 fprintf (SUMA_STDERR,"Error %s: -input option must be specified.\n", FuncName);
04239 exit(1);
04240 }
04241
04242 im = mri_read_1D (IntName);
04243
04244 if (!im) {
04245 SUMA_S_Err("Failed to read file");
04246 exit (1);
04247 }
04248
04249 if (vcol < 0) {
04250 fprintf (SUMA_STDERR,"Error %s: vcol must be > 0\n", FuncName);
04251 exit(1);
04252 }
04253
04254 far = MRI_FLOAT_PTR(im);
04255 if (icol < 0 && icol != -1) {
04256 fprintf (SUMA_STDERR,"Error %s: icol(%d) can only have -1 for a negative value\n", FuncName, icol);
04257 exit(1);
04258 }
04259
04260 if (icol >= im->ny || vcol >= im->ny) {
04261 fprintf (SUMA_STDERR,"Error %s: icol(%d) and vcol(%d) must be < %d\nwhich is the number of columns in %s\n",
04262 FuncName, icol, vcol, im->ny, IntName);
04263 exit(1);
04264 }
04265
04266
04267 if (brfact <=0 || brfact > 1) {
04268 fprintf (SUMA_STDERR,"Error %s: BrightFact must be > 0 and <= 1.\n", FuncName);
04269 exit (1);
04270 }
04271
04272 if (MaskColor[0] < 0 || MaskColor[0] > 1 || MaskColor[1] < 0 || MaskColor[1] > 1 || MaskColor[2] < 0 || MaskColor[2] > 1) {
04273 fprintf (SUMA_STDERR,"Error %s: MaskColor values must be >=0 <=1.\n", FuncName);
04274 exit(1);
04275 }
04276
04277
04278 N_V = im->nx;
04279 V = (float *) SUMA_calloc (N_V, sizeof(float));
04280 iV = (int *) SUMA_calloc (N_V, sizeof(int));
04281 if (!V || !iV) {
04282 fprintf (SUMA_STDERR,"Error %s: Could not allocate for V or iV.\n", FuncName);
04283 exit(1);
04284 }
04285
04286 if (icol < 0) {
04287 for (ii=0; ii < N_V; ++ii) {
04288 iV[ii] = ii;
04289 V[ii] = far[vcol*N_V+ii];
04290 }
04291 } else {
04292 for (ii=0; ii < N_V; ++ii) {
04293 iV[ii] = (int)far[icol*N_V+ii];
04294 V[ii] = far[vcol*N_V+ii];
04295 }
04296 }
04297
04298 mri_free(im); im = NULL;
04299
04300
04301
04302
04303
04304 SUMA_MIN_MAX_VEC(V, N_V, Vmin, Vmax, Vminloc, Vmaxloc)
04305
04306
04307 if (arange == 0.0) {
04308 if (fabs((double)Vmin) > fabs((double)Vmax)) arange = (float)fabs((double)Vmin);
04309 else arange = (float)fabs((double)Vmax);
04310 }
04311
04312 if (ApplyPercClip) {
04313
04314 fprintf (SUMA_STDERR,"%s: Percentile range [%f..%f] is equivalent to ", FuncName, IntRange[0], IntRange[1]);
04315 Vsort = SUMA_PercRange (V, NULL, N_V, IntRange, IntRange, NULL);
04316 fprintf (SUMA_STDERR,"[%f..%f]\n", IntRange[0], IntRange[1]);
04317 ApplyClip = YUP;
04318
04319 if (Vsort) SUMA_free(Vsort);
04320 else {
04321 fprintf (SUMA_STDERR,"Error %s: Error in SUMA_PercRange.\n", FuncName);
04322 exit(1);
04323 }
04324 }
04325
04326
04327
04328 OptScl = SUMA_ScaleToMapOptInit();
04329 if (!OptScl) {
04330 fprintf (SUMA_STDERR,"Error %s: Could not get scaling option structure.\n", FuncName);
04331 exit (1);
04332 }
04333
04334
04335 if (ApplyMask) {
04336 OptScl->ApplyMask = ApplyMask;
04337 OptScl->MaskRange[0] = MaskRange[0]; OptScl->MaskRange[1] = MaskRange[1];
04338 OptScl->MaskColor[0] = MaskColor[0]; OptScl->MaskColor[1] = MaskColor[1]; OptScl->MaskColor[2] = MaskColor[2];
04339 }
04340
04341 if (ApplyClip) {
04342 OptScl->ApplyClip = YUP;
04343 OptScl->IntRange[0] = IntRange[0]; OptScl->IntRange[1] = IntRange[1];
04344 }
04345
04346 OptScl->interpmode = interpmode;
04347
04348 OptScl->BrightFact = brfact;
04349
04350 if (MaskZero) OptScl->MaskZero = YUP;
04351
04352
04353
04354 SV = SUMA_Create_ColorScaledVect(N_V);
04355 if (!SV) {
04356 fprintf (SUMA_STDERR,"Error %s: Could not allocate for SV.\n", FuncName);
04357 exit(1);
04358 }
04359
04360
04361 if (alaAFNI) {
04362 if (LocalHead) {
04363 fprintf (SUMA_STDERR,"%s: Calling SUMA_ScaleToMap_alaAFNI\n", FuncName);
04364 fprintf (SUMA_STDERR,"%s: arange = %f\n", FuncName, arange);
04365 }
04366 if (CM->frac) {
04367 if (CM->frac[0] > 0 && CM->Sgn == -1) {
04368 SUMA_S_Err ("Color map fractions positive with -anr option");
04369 exit(1);
04370 }
04371 if (CM->frac[0] < 0 && CM->Sgn == 1) {
04372 SUMA_S_Err ("Color map fractions negative with -apr option");
04373 exit(1);
04374 }
04375 }
04376
04377 if (Sgn) {
04378 if (Sgn != CM->Sgn) {
04379 SUMA_S_Warn ("Mixing positive maps (all fractions > 0) with -anr option\nor vice versa. That is allowed but know what you're doing.\n");
04380 }
04381 }
04382 if (!SUMA_ScaleToMap_alaAFNI (V, N_V, arange, CM, OptScl, SV)) {
04383 fprintf (SUMA_STDERR,"Error %s: Failed in SUMA_ScaleToMap_alaAFNI.\n", FuncName);
04384 exit(1);
04385 }
04386 } else {
04387 if (LocalHead) fprintf (SUMA_STDERR,"%s: Calling SUMA_ScaleToMap\n", FuncName);
04388 if (!SUMA_ScaleToMap (V, N_V, Vmin, Vmax, CM, OptScl, SV)) {
04389 fprintf (SUMA_STDERR,"Error %s: Failed in SUMA_ScaleToMap.\n", FuncName);
04390 exit(1);
04391 }
04392 }
04393
04394
04395 if (NoMaskCol) {
04396 for (k=0; k < N_V; ++k) {
04397 k3 = 3*k;
04398 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]);
04399 }
04400 } else {
04401 for (k=0; k < N_V; ++k) {
04402 k3 = 3*k;
04403 fprintf (SUMA_STDOUT, "%d %f %f %f\n", iV[k], SV->cV[k3 ], SV->cV[k3+1], SV->cV[k3+2]);
04404 }
04405 }
04406
04407
04408 if (V) SUMA_free(V);
04409 if (iV) SUMA_free(iV);
04410 if (!FromAFNI) if (CM) SUMA_Free_ColorMap (CM);
04411 if (OptScl) SUMA_free(OptScl);
04412 if (SV) SUMA_Free_ColorScaledVect (SV);
04413 #if 0
04414 if (SAC) SAC = SUMA_DestroyAfniColors(SAC);
04415 #else
04416 SAC = NULL;
04417 #endif
04418 SUMA_Free_CommonFields(SUMAg_CF);
04419
04420 SUMA_RETURN (0);
04421 }
04422
04423 #endif
04424
04425
04426
04427
04428
04429
04430 void SUMA_Flip_Color_Map (SUMA_COLOR_MAP *CM)
04431 {
04432 static char FuncName[] = {"SUMA_Flip_Color_Map"};
04433 int lim, i, j, c;
04434 float t;
04435 SUMA_Boolean LocalHead = NOPE;
04436
04437 SUMA_ENTRY;
04438
04439 if (!CM) SUMA_RETURNe;
04440
04441 if (!CM->M) SUMA_RETURNe;
04442
04443 lim = CM->N_Col/2;
04444 for (j=0; j < 3; ++j) {
04445 for (i=0; i < lim; ++i) {
04446 t = CM->M[i][j];
04447 c = CM->N_Col - i - 1;
04448 CM->M[i][j] = CM->M[c][j];
04449 CM->M[c][j] = t;
04450 }
04451 }
04452
04453 if (CM->frac) {
04454 for (i=0; i < lim; ++i) {
04455 t = CM->frac[i];
04456 c = CM->N_Col - i - 1;
04457 CM->frac[i] = CM->frac[c];
04458 CM->frac[c] = t;
04459 }
04460 }
04461
04462 SUMA_RETURNe;
04463 }
04464
04465
04466
04467
04468
04469
04470
04471
04472
04473
04474
04475
04476
04477
04478
04479
04480
04481
04482
04483
04484
04485
04486
04487 float * SUMA_PercRange (float *V, float *Vsort, int N_V, float *PercRange, float *PercRangeVal, int *iPercRangeVal)
04488 {
04489 static char FuncName[] = {"SUMA_PercRange"};
04490 int *isort, il, ih;
04491
04492 SUMA_ENTRY;
04493
04494 if (PercRange[0] < 0 || PercRange[0] > 100 || PercRange[1] < 0 || PercRange[1] > 100) {
04495 fprintf (SUMA_STDERR, "Error %s: Values in PercRange must be between 0 and 100.\nVsort will be freed.\n", FuncName);
04496 if (Vsort) SUMA_free(Vsort);
04497 SUMA_RETURN (NULL);
04498 }
04499
04500 if (!Vsort) {
04501
04502 Vsort = (float *)SUMA_calloc (N_V, sizeof(float));
04503 if (!Vsort) {
04504 fprintf (SUMA_STDERR, "Error %s: Failed to allocate for Vsort.\n", FuncName);
04505 SUMA_RETURN (NULL);
04506 }
04507
04508 SUMA_COPY_VEC (V, Vsort, N_V, float, float);
04509
04510
04511 isort = SUMA_z_qsort (Vsort , N_V ); SUMA_free(isort);
04512 }
04513
04514
04515 il = (int)rint((N_V-1)*PercRange[0]/100.0);
04516 ih = (int)rint((N_V-1)*PercRange[1]/100.0);
04517 PercRangeVal[0] = Vsort[il];
04518 PercRangeVal[1] = Vsort[ih];
04519 if (iPercRangeVal) {
04520 iPercRangeVal[0] = il; iPercRangeVal[1] = ih;
04521 }
04522 SUMA_RETURN (Vsort);
04523 }
04524
04525
04526
04527
04528
04529 double * SUMA_dPercRange (double *V, double *Vsort, int N_V, double *PercRange, double *PercRangeVal, int *iPercRangeVal)
04530 {
04531 static char FuncName[] = {"SUMA_dPercRange"};
04532 int *isort, il, ih;
04533
04534 SUMA_ENTRY;
04535
04536 if (PercRange[0] < 0 || PercRange[0] > 100 || PercRange[1] < 0 || PercRange[1] > 100) {
04537 fprintf (SUMA_STDERR, "Error %s: Values in PercRange must be between 0 and 100.\nVsort will be freed.\n", FuncName);
04538 if (Vsort) SUMA_free(Vsort);
04539 SUMA_RETURN (NULL);
04540 }
04541
04542 if (!Vsort) {
04543
04544 Vsort = (double *)SUMA_calloc (N_V, sizeof(double));
04545 if (!Vsort) {
04546 fprintf (SUMA_STDERR, "Error %s: Failed to allocate for Vsort.\n", FuncName);
04547 SUMA_RETURN (NULL);
04548 }
04549
04550 SUMA_COPY_VEC (V, Vsort, N_V, double, double);
04551
04552
04553 isort = SUMA_z_doubqsort (Vsort , N_V ); SUMA_free(isort);
04554 }
04555
04556
04557 il = (int)rint((N_V-1)*PercRange[0]/100.0);
04558 ih = (int)rint((N_V-1)*PercRange[1]/100.0);
04559 PercRangeVal[0] = Vsort[il];
04560 PercRangeVal[1] = Vsort[ih];
04561 if (iPercRangeVal) {
04562 iPercRangeVal[0] = il; iPercRangeVal[1] = ih;
04563 }
04564 SUMA_RETURN (Vsort);
04565 }
04566
04567
04568
04569
04570
04571
04572
04573
04574
04575
04576
04577
04578
04579
04580
04581
04582
04583
04584
04585
04586
04587
04588
04589
04590
04591
04592
04593 SUMA_OVERLAYS * SUMA_CreateOverlayPointer (int N_Nodes, const char *Name, SUMA_DSET *dset, char *ownerid)
04594 {
04595 static char FuncName[]={"SUMA_CreateOverlayPointer"};
04596 SUMA_OVERLAYS *Sover=NULL;
04597 SUMA_FileName sfn;
04598 int N_Alloc = -1, i=0;
04599 SUMA_Boolean LocalHead = NOPE;
04600
04601 SUMA_ENTRY;
04602
04603 if (!dset) {
04604 SUMA_SL_Err("Need dset");
04605 SUMA_RETURN(NULL);
04606 }
04607
04608 Sover = (SUMA_OVERLAYS *)SUMA_malloc(sizeof(SUMA_OVERLAYS));
04609 if (!Sover) {
04610 fprintf (SUMA_STDERR,"Error %s: Could not allocate for Sover.\n", FuncName);
04611 SUMA_RETURN (NULL);
04612 }
04613
04614 Sover->N_links = 0;
04615 if (ownerid) sprintf(Sover->owner_id, "%s", ownerid);
04616 else Sover->owner_id[0] = '\0';
04617 Sover->LinkedPtrType = SUMA_LINKED_OVERLAY_TYPE;
04618
04619
04620 SUMA_LH("Linking to Dset");
04621 Sover->dset_link = (SUMA_DSET *)SUMA_LinkToPointer ((void *)dset);
04622
04623 if (Sover->dset_link->dnel) {
04624 if (N_Nodes != Sover->dset_link->dnel->vec_len) {
04625 SUMA_SL_Err("N_Nodes not equal to vec_len.");
04626 SUMA_RETURN(NULL);
04627 }
04628 } else { SUMA_SL_Err ("No nel yet !"); SUMA_RETURN(NULL);}
04629
04630
04631 Sover->Name = (char *)SUMA_calloc (strlen(Name)+1, sizeof(char));
04632 Sover->Name = strcpy(Sover->Name, Name);
04633
04634
04635 sfn = SUMA_StripPath((char *)Name);
04636 Sover->Label = sfn.FileName;
04637 if (sfn.Path) SUMA_free(sfn.Path);
04638
04639
04640
04641 SUMA_LH("Allocating for vectors");
04642 N_Alloc = COLP_N_ALLOC(Sover);
04643
04644 if (N_Alloc != N_Nodes) {
04645 SUMA_SL_Err("This is not supposed to be.");
04646 SUMA_RETURN(NULL);
04647 }
04648 Sover->N_NodeDef = N_Nodes;
04649 Sover->NodeDef = (int *) SUMA_calloc(N_Alloc, sizeof(int));
04650 for (i=0; i < Sover->N_NodeDef; ++i) Sover->NodeDef[i] = i;
04651 Sover->FullList = 1;
04652
04653
04654 Sover->ColVec = (float *)SUMA_calloc(N_Alloc*3, sizeof(float));
04655 Sover->LocalOpacity = (float *)SUMA_calloc(N_Alloc, sizeof(float));
04656
04657 if (!Sover->ColVec || !Sover->LocalOpacity || !Sover->NodeDef) {
04658 fprintf (SUMA_STDERR,"Error %s: Could not allocate for Sover fields.\n", FuncName);
04659 SUMA_free(Sover);
04660 SUMA_RETURN (NULL);
04661 }
04662
04663 Sover->GlobalOpacity = -1.0;
04664 Sover->LocalOpacity[0] = -1.0;
04665 Sover->Show = NOPE;
04666 Sover->PlaneOrder = -1;
04667 Sover->isBackGrnd = 0;
04668 Sover->DimFact = 0.3;
04669 Sover->ForceIntRange[0] = 0.0; Sover->ForceIntRange[1] = 0.0;
04670
04671
04672
04673 SUMA_LH("SCM stuff");
04674 if (!SUMAg_CF->scm) {
04675 SUMAg_CF->scm = SUMA_Build_Color_maps();
04676 }
04677 if (!SUMAg_CF->scm) {
04678 SUMA_LH("SUMA color maps not set up.");
04679 Sover->cmapname = NULL;
04680 Sover->OptScl = NULL;
04681 } else {
04682 Sover->cmapname = SUMA_copy_string("bgyr64");
04683 Sover->OptScl = SUMA_ScaleToMapOptInit();
04684 if (!Sover->OptScl) {
04685 fprintf (SUMA_STDERR,"Error %s: Could not get scaling option structure.\n", FuncName);
04686 SUMA_RETURN (NOPE);
04687 }
04688 }
04689
04690 Sover->SymIrange = 0;
04691
04692 SUMA_RETURN (Sover);
04693 }
04694
04695
04696
04697
04698 SUMA_Boolean SUMA_ReleaseOverlay (SUMA_OVERLAYS * Overlays, SUMA_INODE *Overlays_Inode)
04699 {
04700 static char FuncName[]={"SUMA_ReleaseOverlay"};
04701 SUMA_Boolean LocalHead = NOPE;
04702
04703 SUMA_ENTRY;
04704
04705 if (Overlays_Inode || Overlays) {
04706 if (SUMA_ReleaseLink(Overlays_Inode)) {
04707
04708 } else {
04709 if (LocalHead) fprintf (SUMA_STDERR,"%s: Overlay plane %s is free of links, freeing allocated memory ...\n", FuncName, Overlays->Name);
04710 if (Overlays) SUMA_FreeOverlayPointer (Overlays);
04711 if (Overlays_Inode) SUMA_free(Overlays_Inode);
04712 }
04713 }
04714 SUMA_RETURN(YUP);
04715 }
04716
04717
04718
04719
04720
04721
04722
04723
04724
04725
04726
04727
04728 SUMA_Boolean SUMA_FreeOverlayPointer (SUMA_OVERLAYS * Sover)
04729 {
04730 static char FuncName[]={"SUMA_FreeOverlayPointer"};
04731
04732 SUMA_ENTRY;
04733
04734 if (Sover == NULL) {
04735 fprintf (SUMA_STDERR,"Error %s: Sover is NULL, nothing to do. Returning OK flag.\n", FuncName);
04736 SUMA_RETURN (YUP);
04737 }
04738
04739 if (Sover->N_links) {
04740 Sover = (SUMA_OVERLAYS*)SUMA_UnlinkFromPointer((void *)Sover);
04741 SUMA_RETURN (YUP);
04742 }
04743
04744
04745 if (Sover->dset_link) Sover->dset_link = (SUMA_DSET *)SUMA_UnlinkFromPointer((void *)Sover->dset_link);
04746 if (Sover->NodeDef) SUMA_free(Sover->NodeDef);
04747
04748 if (Sover->ColVec) SUMA_free(Sover->ColVec);
04749 if (Sover->LocalOpacity) SUMA_free(Sover->LocalOpacity);
04750 if (Sover->Label) SUMA_free(Sover->Label);
04751 if (Sover->Name) SUMA_free(Sover->Name);
04752 if (Sover->cmapname) SUMA_free(Sover->cmapname);
04753 if (Sover->OptScl) SUMA_free(Sover->OptScl);
04754 SUMA_free(Sover); Sover = NULL;
04755
04756 SUMA_RETURN (YUP);
04757 }
04758
04759
04760
04761
04762
04763
04764
04765
04766
04767
04768
04769
04770
04771
04772 SUMA_OVERLAYS * SUMA_Fetch_OverlayPointer (SUMA_OVERLAYS **Overlays, int N_Overlays, const char * Name, int * OverInd)
04773 {
04774 static char FuncName[]={"SUMA_Fetch_OverlayPointer"};
04775 int i;
04776 SUMA_OVERLAYS *ptr= NULL;
04777 SUMA_Boolean LocalHead = NOPE;
04778
04779 SUMA_ENTRY;
04780
04781 for (i=0; i < N_Overlays; ++i) {
04782 if (!strcmp(Overlays[i]->Name, Name)) {
04783 *OverInd = i;
04784 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Found overlay plane %s, indexed %d.\n", FuncName, Name, i);
04785 SUMA_RETURN (Overlays[i]);
04786 }
04787 }
04788
04789 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Overlay plane %s was not found.\n", FuncName, Name);
04790
04791 *OverInd = -1;
04792
04793 SUMA_RETURN (NULL);
04794 }
04795
04796
04797
04798
04799
04800
04801
04802
04803
04804
04805
04806
04807
04808
04809
04810
04811
04812
04813
04814
04815
04816
04817
04818
04819
04820
04821 SUMA_Boolean SUMA_Overlays_2_GLCOLAR4(SUMA_SurfaceObject *SO, SUMA_SurfaceViewer *SV, GLfloat *glcolar)
04822 {
04823 static char FuncName[]={"SUMA_Overlays_2_GLCOLAR4"};
04824 int ShowOverLays[SUMA_MAX_OVERLAYS], ShowOverLays_Back[SUMA_MAX_OVERLAYS];
04825 int ShowOverLays_sort[SUMA_MAX_OVERLAYS], ShowOverLays_Back_sort[SUMA_MAX_OVERLAYS], iloc[SUMA_MAX_OVERLAYS];
04826 int OverlayOrder_Back[SUMA_MAX_OVERLAYS], OverlayOrder[SUMA_MAX_OVERLAYS];
04827 int i, j, NshowOverlays, NshowOverlays_Back, *isort, i4, i4_0, i4_1, i4_2;
04828 SUMA_Boolean *isColored, *isColored_Fore, *isColored_Back;
04829 GLfloat *glcolar_Fore , *glcolar_Fore_tmp, *glcolar_Back;
04830 float avg_Back, avgfact;
04831 SUMA_OVERLAYS ** Overlays;
04832 int N_Overlays;
04833 int N_Node;
04834 float Back_Modfact;
04835 SUMA_Boolean ShowBackground;
04836 SUMA_Boolean ShowForeground;
04837 SUMA_Boolean LocalHead = NOPE;
04838
04839 SUMA_ENTRY;
04840
04841 if (!SO || !SV || !glcolar) {
04842 SUMA_SL_Err("Null input to SUMA_Overlays_2_GLCOLAR4!");
04843 SUMA_RETURN(NOPE);
04844 }
04845
04846
04847 Overlays = SO->Overlays;
04848 N_Overlays = SO->N_Overlays;
04849 N_Node = SO->N_Node;
04850 Back_Modfact = SV->Back_Modfact;
04851 ShowBackground = SV->ShowBackground;
04852 ShowForeground = SV->ShowForeground;
04853
04854 if (LocalHead) {
04855 fprintf (SUMA_STDOUT, "%s: Showing all overlay planes.\n", FuncName);
04856 SUMA_Show_ColorOverlayPlanes (Overlays, N_Overlays, 0);
04857 }
04858
04859
04860
04861 NshowOverlays = 0;
04862 NshowOverlays_Back = 0;
04863 for (j=0; j < N_Overlays; ++j) {
04864 if (Overlays[j]->Show && Overlays[j]->GlobalOpacity != 0) {
04865 if (Overlays[j]->isBackGrnd) {
04866 ShowOverLays_Back[NshowOverlays_Back] = j;
04867 OverlayOrder_Back[NshowOverlays_Back] = Overlays[j]->PlaneOrder;
04868 ++ NshowOverlays_Back;
04869 }else {
04870 if (SO->SurfCont->ShowCurOnly) {
04871 if (SO->SurfCont->curColPlane == Overlays[j]) {
04872 SUMA_LH("Le ShowCurOnly in action");
04873 ShowOverLays[NshowOverlays] = j;
04874 OverlayOrder[NshowOverlays] = Overlays[j]->PlaneOrder;
04875 ++ NshowOverlays;
04876 }
04877 } else {
04878 ShowOverLays[NshowOverlays] = j;
04879 OverlayOrder[NshowOverlays] = Overlays[j]->PlaneOrder;
04880 ++ NshowOverlays;
04881 }
04882 }
04883 }
04884 }
04885
04886 if (LocalHead) fprintf (SUMA_STDERR,"%s: Found %d Mix overlays and %d Mix-Brightmod overlays.\n", FuncName, NshowOverlays, NshowOverlays_Back);
04887
04888
04889
04890 isColored = (SUMA_Boolean *) SUMA_calloc (N_Node, sizeof(SUMA_Boolean));
04891 if (!isColored) {
04892 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for isColored.\n", FuncName);
04893 SUMA_RETURN (NOPE);
04894 }
04895
04896 glcolar_Back = NULL;
04897 isColored_Back = NULL;
04898 if (ShowBackground) {
04899 if (NshowOverlays_Back) {
04900 glcolar_Back = (GLfloat *) SUMA_calloc (4*N_Node, sizeof(GLfloat));
04901 isColored_Back = (SUMA_Boolean *) SUMA_calloc (N_Node, sizeof(SUMA_Boolean));
04902
04903 if (!isColored_Back || !glcolar_Back) {
04904 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for isColored_Back || glcolar_Back.\n", FuncName);
04905 SUMA_RETURN (NOPE);
04906 }
04907 }
04908 }
04909
04910 isColored_Fore = NULL;
04911 glcolar_Fore = NULL;
04912 if (ShowForeground) {
04913 if (NshowOverlays) {
04914 glcolar_Fore = (GLfloat *) SUMA_calloc (4*N_Node, sizeof(GLfloat));
04915 isColored_Fore = (SUMA_Boolean *) SUMA_calloc (N_Node, sizeof(SUMA_Boolean));
04916
04917 if (!isColored_Fore || !glcolar_Fore) {
04918 fprintf (SUMA_STDERR,"Error %s: Failed to allocate for isColored_Fore || glcolar_Fore.\n", FuncName);
04919 SUMA_RETURN (NOPE);
04920 }
04921 }
04922 }
04923
04924
04925
04926
04927 if (ShowBackground) {
04928
04929
04930 if (NshowOverlays_Back > 1) {
04931 isort = SUMA_z_dqsort (OverlayOrder_Back, NshowOverlays_Back );
04932
04933 for (j=0; j < NshowOverlays_Back; ++j) {
04934 ShowOverLays_Back_sort[j] = ShowOverLays_Back[isort[j]];
04935 }
04936
04937 SUMA_free(isort);
04938 }
04939 if (NshowOverlays_Back == 1) {
04940 ShowOverLays_Back_sort[0] = ShowOverLays_Back[0];
04941 }
04942
04943
04944
04945 if (NshowOverlays_Back) {
04946 if (LocalHead) fprintf (SUMA_STDERR,"%s: Mixing Background colors ...\n", FuncName);
04947
04948 if (!SUMA_MixOverlays (Overlays, N_Overlays, ShowOverLays_Back_sort, NshowOverlays_Back, glcolar_Back, N_Node, isColored_Back, NOPE)) {
04949 fprintf (SUMA_STDERR,"Error %s: Failed in SUMA_MixOverlays.\n", FuncName);
04950 SUMA_RETURN (NOPE);
04951 }
04952 } else {
04953 ShowBackground = NOPE;
04954 }
04955 } else {
04956 NshowOverlays_Back = 0;
04957 }
04958
04959
04960
04961
04962 if (ShowForeground) {
04963
04964
04965 if (NshowOverlays > 1) {
04966 isort = SUMA_z_dqsort (OverlayOrder, NshowOverlays );
04967
04968 for (j=0; j < NshowOverlays; ++j) {
04969 ShowOverLays_sort[j] = ShowOverLays[isort[j]];
04970 }
04971
04972 SUMA_free(isort);
04973 }
04974 if (NshowOverlays == 1) {
04975 ShowOverLays_sort[0] = ShowOverLays[0];
04976 }
04977
04978
04979
04980 if (NshowOverlays) {
04981 if (LocalHead) fprintf (SUMA_STDERR,"%s: Mixing Foreground colors ....\n", FuncName);
04982 if (!SUMA_MixOverlays (Overlays, N_Overlays, ShowOverLays_sort, NshowOverlays, glcolar_Fore, N_Node, isColored_Fore, NOPE)) {
04983 fprintf (SUMA_STDERR,"Error %s: Failed in SUMA_MixOverlays.\n", FuncName);
04984 SUMA_RETURN (NOPE);
04985 }
04986 if (SUMAg_CF->X->NumForeSmoothing > 0) {
04987 glcolar_Fore_tmp = NULL;
04988 glcolar_Fore_tmp = SUMA_SmoothAttr_Neighb_Rec (glcolar_Fore, 4*SO->N_Node, NULL, SO->FN, 4, SUMAg_CF->X->NumForeSmoothing);
04989 if (!glcolar_Fore_tmp) {
04990 SUMA_SL_Err("Smoothing failed.\n");
04991 } else {
04992 SUMA_free(glcolar_Fore); glcolar_Fore = glcolar_Fore_tmp; glcolar_Fore_tmp = NULL;
04993 }
04994 }
04995 } else {
04996 ShowForeground = NOPE;
04997 }
04998 } else {
04999 NshowOverlays = 0;
05000 }
05001
05002
05003
05004 if (NshowOverlays && NshowOverlays_Back) {
05005 if (LocalHead) fprintf (SUMA_STDERR,"%s: Modulating Brightness of Foreground colors ...\n", FuncName);
05006
05007 for (i=0; i < N_Node; ++i) {
05008 avgfact = Back_Modfact / 3.0;
05009 if (isColored_Fore[i] && isColored_Back[i]) {
05010 i4_0 = 4 * i; i4_1 = i4_0 + 1; i4_2 = i4_0 + 2;
05011 if (!Back_Modfact) {
05012 glcolar[i4_0] = glcolar_Fore[i4_0];
05013 glcolar[i4_1] = glcolar_Fore[i4_1];
05014 glcolar[i4_2] = glcolar_Fore[i4_2];
05015 } else {
05016 avg_Back = (glcolar_Back[i4_0] + glcolar_Back[i4_1] + glcolar_Back[i4_2]) * avgfact ;
05017 glcolar[i4_0] = avg_Back * glcolar_Fore[i4_0];
05018 glcolar[i4_1] = avg_Back * glcolar_Fore[i4_1];
05019 glcolar[i4_2] = avg_Back * glcolar_Fore[i4_2];
05020 }
05021 isColored[i] = YUP;
05022 continue;
05023 }
05024 if (isColored_Fore[i]) {
05025 i4 = 4 * i;
05026 glcolar[i4] = glcolar_Fore[i4]; ++i4;
05027 glcolar[i4] = glcolar_Fore[i4]; ++i4;
05028 glcolar[i4] = glcolar_Fore[i4]; ++i4;
05029 isColored[i] = YUP;
05030 continue;
05031 }
05032 if (isColored_Back[i]) {
05033 i4 = 4 * i;
05034 glcolar[i4] = glcolar_Back[i4]; ++i4;
05035 glcolar[i4] = glcolar_Back[i4]; ++i4;
05036 glcolar[i4] = glcolar_Back[i4]; ++i4;
05037 isColored[i] = YUP;
05038 continue;
05039 } else {
05040
05041 i4 = 4 * i;
05042 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05043 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05044 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05045 isColored[i] = NOPE;
05046 }
05047 }
05048
05049 if (LocalHead) fprintf (SUMA_STDERR,"%s: Done Modulating Brightness of overlay colors.\n", FuncName);
05050 }
05051 if (NshowOverlays && !NshowOverlays_Back) {
05052 if (LocalHead) fprintf (SUMA_STDERR,"%s: Only Foreground colors.\n", FuncName);
05053 for (i=0; i < N_Node; ++i) {
05054 if (isColored_Fore[i]) {
05055 i4 = 4 * i;
05056 glcolar[i4] = glcolar_Fore[i4]; ++i4;
05057 glcolar[i4] = glcolar_Fore[i4]; ++i4;
05058 glcolar[i4] = glcolar_Fore[i4]; ++i4;
05059 isColored[i] = YUP;
05060 continue;
05061 } else {
05062 i4 = 4 * i;
05063 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05064 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05065 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05066 isColored[i] = NOPE;
05067 }
05068 }
05069 }
05070
05071 if (!NshowOverlays && NshowOverlays_Back) {
05072 if (LocalHead) fprintf (SUMA_STDERR,"%s: Only Background colors.\n", FuncName);
05073 for (i=0; i < N_Node; ++i) {
05074 if (isColored_Back[i]) {
05075 i4 = 4 * i;
05076 glcolar[i4] = glcolar_Back[i4]; ++i4;
05077 glcolar[i4] = glcolar_Back[i4]; ++i4;
05078 glcolar[i4] = glcolar_Back[i4]; ++i4;
05079 isColored[i] = YUP;
05080 continue;
05081 } else {
05082 i4 = 4 * i;
05083 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05084 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05085 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05086 isColored[i] = NOPE;
05087 }
05088 }
05089 }
05090
05091 if (!(ShowBackground) && !ShowForeground) {
05092 for (i=0; i < N_Node; ++i) {
05093 i4 = 4 * i;
05094 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05095 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05096 glcolar[i4] = SUMA_GRAY_NODE_COLOR; ++i4;
05097 }
05098 }
05099
05100
05101 if (isColored) SUMA_free(isColored);
05102 if (isColored_Back) SUMA_free(isColored_Back);
05103 if (glcolar_Back) SUMA_free(glcolar_Back);
05104 if (isColored_Fore) SUMA_free(isColored_Fore);
05105 if (glcolar_Fore) SUMA_free(glcolar_Fore);
05106
05107 SUMA_RETURN (YUP);
05108 }
05109
05110
05111
05112
05113
05114
05115
05116
05117
05118
05119
05120
05121
05122
05123
05124
05125 SUMA_Boolean SUMA_MixOverlays (SUMA_OVERLAYS ** Overlays, int N_Overlays, int *ShowOverlays, int NshowOverlays, GLfloat *glcolar, int N_Node, SUMA_Boolean *isColored, SUMA_Boolean FILL)
05126 {
05127 static char FuncName[] = {"SUMA_MixOverlays"};
05128 int i, j;
05129 int *NodeDef, N_NodeDef = -1;
05130 SUMA_Boolean Full, Fill, Locl, Glob;
05131 SUMA_Boolean LocalHead = NOPE;
05132
05133 SUMA_ENTRY;
05134
05135 if (!Overlays) {
05136 SUMA_SL_Err("Null Overlays!");
05137 SUMA_RETURN(NOPE);
05138 }
05139 if (!glcolar) {
05140 SUMA_SL_Err("Null glcolar!");
05141 SUMA_RETURN(NOPE);
05142 }
05143 if (!isColored) {
05144 fprintf (SUMA_STDERR, "Error %s: isColored is NULL.\n", FuncName);
05145 SUMA_RETURN (NOPE);
05146 }
05147 if (!ShowOverlays) {
05148 SUMA_SL_Err("NULL ShowOverlays");
05149 SUMA_RETURN (NOPE);
05150 }
05151 if (!NshowOverlays) {
05152 fprintf (SUMA_STDERR, "Warning %s: Nothing to do.\n", FuncName);
05153 if (FILL) {
05154 fprintf (SUMA_STDERR, "Warning %s: Filling with blank default color\n", FuncName);
05155 SUMA_FillBlanks_GLCOLAR4(isColored, N_Node, SUMA_GRAY_NODE_COLOR, SUMA_GRAY_NODE_COLOR, SUMA_GRAY_NODE_COLOR, glcolar);
05156 }
05157 SUMA_RETURN (YUP);
05158 }
05159
05160
05161 Full = YUP;
05162 Glob = YUP;
05163 Locl = YUP;
05164 Fill = YUP;
05165 for (j=0; j<NshowOverlays; ++j) {
05166 Full = YUP;
05167 Glob = YUP;
05168 Locl = YUP;
05169 Fill = YUP;
05170
05171 i = ShowOverlays[j];
05172 if (!Overlays[i]) {
05173 fprintf(SUMA_STDERR,"Error %s:\nNULL ShowOverlays[%d]\n", FuncName, i);
05174 SUMA_RETURN (NOPE);
05175 }
05176
05177
05178 if (LocalHead) fprintf (SUMA_STDOUT, "%s: Full listing flag: %d\n", FuncName, Overlays[i]->FullList);
05179 if (Overlays[i]->FullList) { Fill = NOPE; }
05180 else { Full = NOPE; }
05181
05182 if (j > 0) {
05183
05184 if (Overlays[i]->GlobalOpacity < 0.0) { Glob = NOPE; }
05185
05186
05187 if (Overlays[i]->LocalOpacity[0] < 0) { Locl = NOPE; }
05188 } else {
05189 Glob = NOPE; Locl = NOPE;
05190 }
05191
05192 NodeDef = COLP_NODEDEF(Overlays[i]);
05193 N_NodeDef = COLP_N_NODEDEF(Overlays[i]);
05194
05195
05196 if (LocalHead)
05197 fprintf (SUMA_STDOUT,"%s: Building color layer %d Overlay #%d: %s ...\nFull=%d, Glob=%d (Globopacity %f), Locl=%d,Fill=%d\n", \
05198 FuncName, j, i, Overlays[i]->Name, (int)Full, (int)Glob, Overlays[i]->GlobalOpacity, (int)Locl, (int)Fill);
05199
05200
05201
05202 if (Full && Glob && Locl) {
05203 if (SUMAg_CF->ColMixMode == SUMA_ORIG_MIX_MODE) {
05204 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_FGL_AR4op ...\n", FuncName);
05205
05206
05207 SUMA_RGBv_FGL_AR4op(\
05208 Overlays[i]->ColVec, glcolar, N_Node, Overlays[i]->GlobalOpacity, Overlays[i]->LocalOpacity, isColored);
05209 } else if (SUMAg_CF->ColMixMode == SUMA_4AML) {
05210 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_FGL_AR4op2 ...\n", FuncName);
05211 SUMA_RGBv_FGL_AR4op2(\
05212 Overlays[i]->ColVec, glcolar, N_Node, Overlays[i]->GlobalOpacity, Overlays[i]->LocalOpacity, isColored);
05213 }
05214 }
05215
05216 if (!Full && Glob && Locl) {
05217 if (SUMAg_CF->ColMixMode == SUMA_ORIG_MIX_MODE) {
05218 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_PGL_AR4op ...\n", FuncName);
05219
05220 SUMA_RGBv_PGL_AR4op(\
05221 Overlays[i]->ColVec, NodeDef, glcolar, N_NodeDef, isColored, Overlays[i]->GlobalOpacity, Overlays[i]->LocalOpacity, N_Node);
05222 } else if (SUMAg_CF->ColMixMode == SUMA_4AML) {
05223 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_PGL_AR4op2 ...\n", FuncName);
05224 SUMA_RGBv_PGL_AR4op2(\
05225 Overlays[i]->ColVec, NodeDef, glcolar, N_NodeDef, isColored, Overlays[i]->GlobalOpacity, Overlays[i]->LocalOpacity, N_Node);
05226 }
05227 }
05228
05229 if (Full && !Glob && Locl) {
05230 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_FnGL_AR4op...\n", FuncName);
05231
05232 SUMA_RGBv_FnGL_AR4op(\
05233 Overlays[i]->ColVec, glcolar, N_Node, Overlays[i]->LocalOpacity, isColored);
05234 }
05235
05236 if (!Full && !Glob && Locl) {
05237 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_PnGL_AR4op ...\n", FuncName);
05238
05239 SUMA_RGBv_PnGL_AR4op(\
05240 Overlays[i]->ColVec, NodeDef, glcolar, N_NodeDef, isColored, Overlays[i]->LocalOpacity, N_Node);
05241 }
05242
05243 if (Full && !Glob && !Locl) {
05244 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_FnGnL_AR4op ...\n", FuncName);
05245
05246 SUMA_RGBv_FnGnL_AR4op(\
05247 Overlays[i]->ColVec, glcolar, N_Node, isColored);
05248 }
05249
05250 if (!Full && !Glob && !Locl) {
05251 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_PnGnL_AR4op ...\n", FuncName);
05252
05253 SUMA_RGBv_PnGnL_AR4op(\
05254 Overlays[i]->ColVec, NodeDef, glcolar, N_NodeDef, isColored, N_Node);
05255 }
05256
05257 if (Full && Glob && !Locl) {
05258 if (SUMAg_CF->ColMixMode == SUMA_ORIG_MIX_MODE) {
05259 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_FGnL_AR4op...\n", FuncName);
05260
05261 SUMA_RGBv_FGnL_AR4op(\
05262 Overlays[i]->ColVec, glcolar, N_Node, Overlays[i]->GlobalOpacity, isColored);
05263 } else if (SUMAg_CF->ColMixMode == SUMA_4AML){
05264 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_FGnL_AR4op2...\n", FuncName);
05265 SUMA_RGBv_FGnL_AR4op2(\
05266 Overlays[i]->ColVec, glcolar, N_Node, Overlays[i]->GlobalOpacity, isColored);
05267 }
05268
05269 }
05270
05271 if (!Full && Glob && !Locl) {
05272 if (SUMAg_CF->ColMixMode == SUMA_ORIG_MIX_MODE) {
05273 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_PGnL_AR4op...\n", FuncName);
05274
05275 SUMA_RGBv_PGnL_AR4op(\
05276 Overlays[i]->ColVec, NodeDef, glcolar, N_NodeDef, isColored, Overlays[i]->GlobalOpacity, N_Node);
05277 } else if (SUMAg_CF->ColMixMode == SUMA_4AML){
05278 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Calling SUMA_RGBv_PGnL_AR4op2...\n", FuncName);
05279 SUMA_RGBv_PGnL_AR4op2(\
05280 Overlays[i]->ColVec, NodeDef, glcolar, N_NodeDef, isColored, Overlays[i]->GlobalOpacity, N_Node);
05281 }
05282 }
05283
05284 }
05285
05286 if (FILL && Fill) {
05287 if (LocalHead) fprintf (SUMA_STDOUT,"%s: Some nodes received no colors from any of the overplanes, filling them with background color ...\n", FuncName);
05288 SUMA_FillBlanks_GLCOLAR4(isColored, N_Node, SUMA_GRAY_NODE_COLOR, SUMA_GRAY_NODE_COLOR, SUMA_GRAY_NODE_COLOR, glcolar);
05289 SUMA_RETURN (YUP);
05290 }
05291
05292 SUMA_RETURN (YUP);
05293 }
05294
05295
05296
05297
05298
05299
05300
05301
05302
05303
05304
05305 SUMA_Boolean SUMA_Show_ColorOverlayPlanes (SUMA_OVERLAYS **Overlays, int N_Overlays, int detail)
05306 {
05307 static char FuncName[]={"SUMA_Show_ColorOverlayPlanes"};
05308 char *s;
05309
05310 SUMA_ENTRY;
05311
05312 s = SUMA_ColorOverlayPlane_Info (Overlays, N_Overlays, detail);
05313 if (s) {
05314 fprintf (SUMA_STDERR,"%s\n", s);
05315 SUMA_free(s);
05316 }
05317
05318 SUMA_RETURN (YUP);
05319 }
05320
05321
05322
05323
05324
05325 char *SUMA_ColorOverlayPlane_Info (SUMA_OVERLAYS **Overlays, int N_Overlays, int detail)
05326 {
05327 static char FuncName[]={"SUMA_ColorOverlayPlane_Info"};
05328 char stmp[1000], *s = NULL, *s2 = NULL;
05329 int i, j, ShowN, icmap;
05330 SUMA_COLOR_MAP *ColMap=NULL;
05331 int N_Alloc = -1, *NodeDef=NULL, N_NodeDef = -1;
05332
05333 SUMA_STRING *SS = NULL;
05334
05335 SUMA_ENTRY;
05336
05337 SS = SUMA_StringAppend (NULL, NULL);
05338
05339 sprintf (stmp,"Info on %d color overlay planes:\n---------------------------------\n", N_Overlays);
05340 SS = SUMA_StringAppend (SS,stmp);
05341 for (i=0; i < N_Overlays; ++i) {
05342 if (Overlays[i]) {
05343 sprintf (stmp,"Overlay plane %s:\norder %d, indexed %d\nDimFact %f, global opacity %f, isBackGrnd (isBackground) %d.\n ForceIntRange %f, %f.\nSymIrange = %d\n",
05344 Overlays[i]->Name, Overlays[i]->PlaneOrder, i, Overlays[i]->DimFact, Overlays[i]->GlobalOpacity, Overlays[i]->isBackGrnd,
05345 Overlays[i]->ForceIntRange[0], Overlays[i]->ForceIntRange[1], Overlays[i]->SymIrange);
05346 SS = SUMA_StringAppend (SS,stmp);
05347 SS = SUMA_StringAppend_va (SS, "N_links = %d\n", Overlays[i]->N_links);
05348 SS = SUMA_StringAppend_va (SS, "LinkedPtrType = %d\n", Overlays[i]->LinkedPtrType);
05349 SS = SUMA_StringAppend_va (SS, "owner_id = %s\n", Overlays[i]->owner_id);
05350 NodeDef = COLP_NODEDEF(Overlays[i]);
05351 N_NodeDef = COLP_N_NODEDEF(Overlays[i]);
05352 N_Alloc = COLP_N_ALLOC(Overlays[i]);
05353 sprintf (stmp,"Show=%d, N_Alloc=%d, N_NodeDef=%d\n", (int)Overlays[i]->Show, N_Alloc, N_NodeDef);
05354 SS = SUMA_StringAppend (SS,stmp);
05355 if (detail > 1) {
05356 ShowN = N_NodeDef;
05357 } else {
05358 if (N_NodeDef > 5) ShowN = 5;
05359 else ShowN = N_NodeDef;
05360 }
05361 SS = SUMA_StringAppend (SS,"\n");
05362 sprintf (stmp,"\tindex\tR\tG\tB\tLocOp\n");
05363 SS = SUMA_StringAppend (SS,stmp);
05364 for (j=0; j < ShowN; ++j) {
05365 SS = SUMA_StringAppend_va (SS, "\t%d\t%.3f\t%.3f\t%.3f\t%.3f\n",
05366 NodeDef[j], Overlays[i]->ColVec[3*j],
05367 Overlays[i]->ColVec[3*j+1], Overlays[i]->ColVec[3*j+2],
05368 Overlays[i]->LocalOpacity[j]);
05369 }
05370 SS = SUMA_StringAppend (SS,"\n");
05371 if (!Overlays[i]->cmapname) SS = SUMA_StringAppend (SS,"cmapname = NULL\n");
05372 else SS = SUMA_StringAppend_va (SS,"cmapname = %s\n", Overlays[i]->cmapname);
05373
05374 if (!SUMAg_CF->scm) {
05375 static int try_once=0;
05376 if (!try_once) { SUMAg_CF->scm = SUMA_Build_Color_maps(); ++ try_once; }
05377 }
05378 if (SUMAg_CF->scm) {
05379 icmap = SUMA_Find_ColorMap ( Overlays[i]->cmapname, SUMAg_CF->scm->CMv, SUMAg_CF->scm->N_maps, -2 );
05380 if (icmap < 0) { SS = SUMA_StringAppend (SS,"cmap not found.\n"); }
05381 else {
05382 ColMap = SUMAg_CF->scm->CMv[icmap];
05383 s2 = SUMA_ColorMapVec_Info(&ColMap, 1, detail);
05384 SS = SUMA_StringAppend (SS, s2); SUMA_free(s2); s2 = NULL;
05385 }
05386 s2 = SUMA_ScaleToMapOpt_Info (Overlays[i]->OptScl, 0);
05387 SS = SUMA_StringAppend (SS, s2); SUMA_free(s2); s2 = NULL;
05388 } else {
05389 SS = SUMA_StringAppend (SS,"\tNULL SUMA color maps.\n");
05390 }
05391 } else {
05392 SS = SUMA_StringAppend (SS,"\tNULL overlay plane.\n");
05393 }
05394 }
05395
05396 SS = SUMA_StringAppend (SS, NULL);
05397
05398 s = SS->s;
05399 SUMA_free(SS);
05400
05401 SUMA_RETURN(s);
05402 }
05403
05404 SUMA_Boolean SUMA_ShowScaleToMapOpt(SUMA_SCALE_TO_MAP_OPT *OptScl, FILE *Out, int detail)
05405 {
05406 static char FuncName[]={"SUMA_ShowScaleToMapOpt"};
05407 char *s=NULL;
05408
05409 SUMA_ENTRY;
05410
05411 if (!Out) Out = stdout;
05412
05413 s = SUMA_ScaleToMapOpt_Info(OptScl, detail);
05414
05415 fprintf (Out, "%s\n", s);
05416
05417 if (s) SUMA_free(s); s = NULL;
05418
05419 SUMA_RETURN(YUP);
05420 }
05421
05422 char *SUMA_ScaleToMapOpt_Info (SUMA_SCALE_TO_MAP_OPT *OptScl, int detail)
05423 {
05424 static char FuncName[]={"SUMA_ScaleToMapOpt_Info"};
05425 char *s = NULL;
05426 SUMA_STRING *SS = NULL;
05427
05428 SUMA_ENTRY;
05429 SS = SUMA_StringAppend (NULL, NULL);
05430
05431 if (!OptScl) { SS = SUMA_StringAppend (SS, "NULL ScaleToMap options\n"); }
05432 else {
05433 SS = SUMA_StringAppend (SS, "ScaleToMap options:\n");
05434 SS = SUMA_StringAppend_va (SS, "ApplyMask = %d\n", OptScl->ApplyMask);
05435 SS = SUMA_StringAppend_va (SS, "MaskRange = %f %f\n",
05436 OptScl->MaskRange[0], OptScl->MaskRange[1]);
05437 SS = SUMA_StringAppend_va (SS, "MaskColor = %f %f %f\n",
05438 OptScl->MaskColor[0], OptScl->MaskColor[1], OptScl->MaskColor[2]);
05439 SS = SUMA_StringAppend_va (SS, "ApplyClip = %d\n", OptScl->ApplyClip);
05440 SS = SUMA_StringAppend_va (SS, "BrightFact = %f\n", OptScl->BrightFact);
05441 SS = SUMA_StringAppend_va (SS, "MaskZero = %d\n", OptScl->MaskZero);
05442 SS = SUMA_StringAppend_va (SS, "find = %d\n", OptScl->find);
05443 SS = SUMA_StringAppend_va (SS, "IntRange = %f %f\n",
05444 OptScl->IntRange[0], OptScl->IntRange[1]);
05445 SS = SUMA_StringAppend_va (SS, "AutoIntRange = %d\n", OptScl->AutoIntRange);
05446 SS = SUMA_StringAppend_va (SS, "tind = %d (use:%d). Mode %d\n", OptScl->tind, OptScl->UseThr, OptScl->ThrMode);
05447 SS = SUMA_StringAppend_va (SS, "ThreshRange = %f %f\n",
05448 OptScl->ThreshRange[0], OptScl->ThreshRange[1]);
05449 SS = SUMA_StringAppend_va (SS, "bind = %d (use:%d)\n", OptScl->bind, OptScl->UseBrt);
05450 SS = SUMA_StringAppend_va (SS, "BrightRange = %f %f\n",
05451 OptScl->BrightRange[0], OptScl->BrightRange[1]);
05452 SS = SUMA_StringAppend_va (SS, "BrightMap = %f %f\n",
05453 OptScl->BrightMap[0], OptScl->BrightMap[1]);
05454 SS = SUMA_StringAppend_va (SS, "AutoBrtRange = %d\n", OptScl->AutoBrtRange);
05455 SS = SUMA_StringAppend_va (SS, "alaAFNI = %d\n", OptScl->alaAFNI);
05456 SS = SUMA_StringAppend_va (SS, "interpmode = %d\n", OptScl->interpmode);
05457 SS = SUMA_StringAppend_va (SS, "BiasMode = %d, Range=%f, %f \n",
05458 OptScl->DoBias, OptScl->CoordBiasRange[0], OptScl->CoordBiasRange[1]);
05459 if (OptScl->BiasVect) SS = SUMA_StringAppend_va (SS, "BiasVect is NOT NULL\n");
05460 else SS = SUMA_StringAppend_va (SS, "BiasVect is NULL\n");
05461 }
05462 SUMA_SS2S(SS, s);
05463 SUMA_RETURN(s);
05464 }
05465
05466
05467
05468
05469 void SUMA_FreeOverlayListDatum (void *OLDv)
05470 {
05471 static char FuncName[]={"SUMA_FreeOverlayListDatum"};
05472 SUMA_Boolean LocalHead = NOPE;
05473
05474 SUMA_ENTRY;
05475
05476 if (OLDv) SUMA_free(OLDv);
05477
05478 SUMA_RETURNe;
05479 }
05480
05481
05482
05483
05484
05485
05486
05487
05488
05489
05490
05491
05492
05493
05494
05495
05496
05497
05498 DList * SUMA_OverlaysToOrderedList (SUMA_SurfaceObject *SO, int Opt)
05499 {
05500 static char FuncName[]={"SUMA_OverlaysToOrderedList"};
05501 DList *listop = NULL;
05502 DListElmt *Elmop=NULL;
05503 SUMA_OVERLAY_LIST_DATUM *OvD = NULL, *oOvD = NULL;
05504 int i, Shift, ShftPlaneOrder, oShftPlaneOrder;
05505 SUMA_OVERLAYS *oPlane=NULL;
05506 SUMA_Boolean Found, LocalHead = NOPE;
05507
05508 SUMA_ENTRY;
05509
05510 listop = (DList *)SUMA_malloc(sizeof(DList));
05511
05512 dlist_init(listop, SUMA_FreeOverlayListDatum);
05513 SUMA_LH("Considering loop");
05514 for (i=0; i < SO->N_Overlays; ++i) {
05515 SUMA_LH("In Loop");
05516 OvD = (SUMA_OVERLAY_LIST_DATUM *)SUMA_malloc(sizeof(SUMA_OVERLAY_LIST_DATUM));
05517 OvD->Overlay = SO->Overlays[i];
05518 if (!OvD->Overlay) {
05519 SUMA_LH("NULL Overlay");
05520 }
05521 SUMA_LH("Here");
05522 if (OvD->Overlay->isBackGrnd && Opt == 1) continue;
05523 if (!OvD->Overlay->isBackGrnd && Opt == -1) continue;
05524 if (!listop->size) {
05525 SUMA_LH("Very first");
05526 dlist_ins_next(listop, dlist_tail(listop), (void*)OvD);
05527 }else {
05528 Elmop = NULL;
05529 do {
05530 SUMA_LH("Searching");
05531 Found = NOPE;
05532 if (!Elmop) {
05533 Elmop = dlist_head(listop);
05534 } else {
05535 Elmop = dlist_next(Elmop);
05536 }
05537
05538 oOvD = (SUMA_OVERLAY_LIST_DATUM *)Elmop->data;
05539
05540
05541 Shift = SO->N_Overlays;
05542
05543 if (OvD->Overlay->isBackGrnd) ShftPlaneOrder = OvD->Overlay->PlaneOrder - Shift;
05544 else ShftPlaneOrder = OvD->Overlay->PlaneOrder;
05545
05546 if (oOvD->Overlay->isBackGrnd) oShftPlaneOrder = oOvD->Overlay->PlaneOrder - Shift;
05547 else oShftPlaneOrder = oOvD->Overlay->PlaneOrder;
05548
05549 if (ShftPlaneOrder <= oShftPlaneOrder) {
05550 SUMA_LH ("Ins Prev");
05551 dlist_ins_prev(listop, Elmop, (void *)OvD);
05552 Found = YUP;
05553 } else if (Elmop == dlist_tail(listop)) {
05554 SUMA_LH ("Ins Next");
05555
05556 dlist_ins_next(listop, Elmop, (void *)OvD);
05557 Found = YUP;
05558 }
05559 } while (!Found);
05560 }
05561 }
05562
05563
05564
05565
05566
05567 SUMA_LH("Changing list order to plane order");
05568 SUMA_ListOrderToPlaneOrder (listop);
05569
05570 SUMA_RETURN(listop);
05571 }
05572
05573
05574
05575
05576 SUMA_Boolean SUMA_ListOrderToPlaneOrder (DList *listop)
05577 {
05578 static char FuncName[]={"SUMA_ListOrderToPlaneOrder"};
05579 SUMA_OVERLAY_LIST_DATUM *OvD = NULL;
05580 int i, fg_shift = 0;
05581 DListElmt *Elmop=NULL;
05582
05583 SUMA_ENTRY;
05584
05585
05586 if (listop->size) {
05587 Elmop = NULL;
05588 i = 0;
05589 do {
05590 if (!Elmop) Elmop = dlist_head(listop);
05591 else Elmop = Elmop->next;
05592 OvD = (SUMA_OVERLAY_LIST_DATUM *)Elmop->data;
05593 if (OvD->Overlay->isBackGrnd) {
05594 OvD->Overlay->PlaneOrder = i;
05595 ++i;
05596 }
05597 } while (!dlist_is_tail(Elmop));
05598 }
05599
05600
05601 if (listop->size) {
05602 Elmop = NULL;
05603 i = 0;
05604 do {
05605 if (!Elmop) Elmop = dlist_head(listop);
05606 else Elmop = Elmop->next;
05607 OvD = (SUMA_OVERLAY_LIST_DATUM *)Elmop->data;
05608 if (!OvD->Overlay->isBackGrnd) {
05609 OvD->Overlay->PlaneOrder = i;
05610 ++i;
05611 }
05612 } while (!dlist_is_tail(Elmop));
05613 }
05614
05615
05616 SUMA_RETURN(YUP);
05617 }
05618
05619
05620
05621
05622 int SUMA_GetLargestBackroundOrder (DList *listop)
05623 {
05624 static char FuncName[]={"SUMA_GetLargestBackroundOrder"};
05625 int Order, i;
05626 DListElmt *Elmop=NULL;
05627 SUMA_OVERLAY_LIST_DATUM *OvD = NULL;
05628 SUMA_Boolean LocalHead = NOPE;
05629
05630 SUMA_ENTRY;
05631
05632 Order = 0;
05633 Elmop = NULL;
05634 do {
05635 if (!Elmop) Elmop = dlist_head(listop);
05636 else Elmop = Elmop->next;
05637 OvD = (SUMA_OVERLAY_LIST_DATUM *)Elmop->data;
05638 if (OvD->Overlay->isBackGrnd) {
05639 if (OvD->Overlay->PlaneOrder > Order) Order = OvD->Overlay->PlaneOrder;
05640 }
05641 ++i;
05642 } while (!dlist_is_tail(Elmop));
05643
05644 if (LocalHead) {
05645 fprintf (SUMA_STDERR,"%s: Highest background order found is %d\n", FuncName, Order);
05646 }
05647
05648 SUMA_RETURN(Order);
05649 }
05650
05651
05652
05653
05654 int SUMA_GetSmallestForegroundOrder (DList *listop)
05655 {
05656 static char FuncName[]={"SUMA_GetSmallestForegroundOrder"};
05657 int Order, i;
05658 DListElmt *Elmop=NULL;
05659 SUMA_OVERLAY_LIST_DATUM *OvD = NULL, *oOvD = NULL;
05660 SUMA_Boolean LocalHead = NOPE;
05661
05662 SUMA_ENTRY;
05663
05664 Order = listop->size -1 ;
05665 Elmop = NULL;
05666 do {
05667 if (!Elmop) Elmop = dlist_head(listop);
05668 else Elmop = Elmop->next;
05669 OvD = (SUMA_OVERLAY_LIST_DATUM *)Elmop->data;
05670 if (!OvD->Overlay->isBackGrnd) {
05671 if (OvD->Overlay->PlaneOrder < Order) Order = OvD->Overlay->PlaneOrder;
05672 }
05673 ++i;
05674 } while (!dlist_is_tail(Elmop));
05675
05676 if (LocalHead) {
05677 fprintf (SUMA_STDERR,"%s: Lowest foreground order found is %d\n", FuncName, Order);
05678 }
05679
05680 SUMA_RETURN(Order);
05681 }
05682
05683
05684
05685
05686 SUMA_Boolean SUMA_isOverlayOfSO (SUMA_SurfaceObject *SO, SUMA_OVERLAYS *Plane)
05687 {
05688 static char FuncName[]={"SUMA_isOverlayOfSO"};
05689 int i;
05690 SUMA_Boolean LocalHead = NOPE;
05691
05692 SUMA_ENTRY;
05693
05694 for (i=0; i< SO->N_Overlays; ++i) if (SO->Overlays[i] == Plane) SUMA_RETURN(YUP);
05695
05696 SUMA_RETURN(NOPE);
05697 }
05698
05699 void SUMA_Print_PlaneOrder (SUMA_SurfaceObject *SO, FILE *Out)
05700 {
05701 static char FuncName[]={"SUMA_Print_PlaneOrder"};
05702 char *s;
05703
05704 SUMA_ENTRY;
05705
05706 if (Out == NULL) Out = stdout;
05707
05708 s = SUMA_PlaneOrder_Info(SO);
05709
05710 if (s) {
05711 fprintf (Out, "%s", s);
05712 SUMA_free(s);
05713 }else {
05714 fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_PlaneOrder_Info.\n", FuncName);
05715 }
05716
05717 SUMA_RETURNe;
05718 }
05719
05720
05721
05722
05723 char * SUMA_PlaneOrder_Info (SUMA_SurfaceObject *SO)
05724 {
05725 static char FuncName[]={"SUMA_PlaneOrder_Info"};
05726 char stmp[1000], *s = NULL;
05727 SUMA_STRING *SS = NULL;
05728 DList *list=NULL;
05729 DListElmt *Elm=NULL;
05730 SUMA_OVERLAY_LIST_DATUM *OvD=NULL;
05731
05732 SUMA_ENTRY;
05733
05734
05735 SS = SUMA_StringAppend (NULL, NULL);
05736
05737 if (!(list = SUMA_OverlaysToOrderedList (SO, -1))) {
05738 SS = SUMA_StringAppend (SS,"NULL Background list\n");
05739 }else if (!list->size) {
05740 SS = SUMA_StringAppend (SS,"Empty Background list\n");
05741 } else {
05742 Elm=NULL;
05743 do {
05744 if (!Elm) Elm = dlist_head(list);
05745 else Elm = Elm->next;
05746 OvD = (SUMA_OVERLAY_LIST_DATUM *)Elm->data;
05747 sprintf (stmp,"BK: %s o%d (%s)\n", OvD->Overlay->Label, OvD->Overlay->PlaneOrder, OvD->Overlay->Name );
05748 SS = SUMA_StringAppend (SS,stmp);
05749 } while (Elm != dlist_tail(list));
05750 }
05751
05752 if (!(list = SUMA_OverlaysToOrderedList (SO, 1))) {
05753 SS = SUMA_StringAppend (SS,"NULL Foreground list\n");
05754 }else if (!list->size) {
05755 SS = SUMA_StringAppend (SS,"Empty Foreground list\n");
05756 } else {
05757 Elm=NULL;
05758 do {
05759 if (!Elm) Elm = dlist_head(list);
05760 else Elm = Elm->next;
05761 OvD = (SUMA_OVERLAY_LIST_DATUM *)Elm->data;
05762 sprintf (stmp,"FG: %s o%d (%s)\n", OvD->Overlay->Label, OvD->Overlay->PlaneOrder, OvD->Overlay->Name );
05763 SS = SUMA_StringAppend (SS,stmp);
05764 } while (Elm != dlist_tail(list));
05765 }
05766
05767 s = SS->s;
05768 SUMA_free(SS);
05769
05770 SUMA_RETURN (s);
05771 }
05772
05773
05774
05775
05776 SUMA_Boolean SUMA_MovePlaneUp (SUMA_SurfaceObject *SO, char *Name)
05777 {
05778 static char FuncName[]={"SUMA_MovePlaneUp"};
05779 SUMA_OVERLAYS *Overlay=NULL;
05780 SUMA_OVERLAY_LIST_DATUM *OvD=NULL;
05781 DList *list=NULL;
05782 DListElmt *Elm = NULL;
05783 int junk=0;
05784 SUMA_Boolean Found = NOPE, LocalHead = NOPE;
05785
05786 SUMA_ENTRY;
05787
05788
05789 SUMA_LH("Searching for plane");
05790 if (!(Overlay = SUMA_Fetch_OverlayPointer(SO->Overlays, SO->N_Overlays, Name, &junk))) {
05791 SUMA_S_Err("Plane does not exist in SO->Overlays. (identified by name)");
05792 SUMA_RETURN (NOPE);
05793 }
05794
05795
05796 SUMA_LH("Creating list");
05797 if (Overlay->isBackGrnd) list = SUMA_OverlaysToOrderedList (SO, -1);
05798 else list = SUMA_OverlaysToOrderedList (SO, 1);
05799 if (!list) {
05800 SUMA_S_Err("NULL list");
05801 SUMA_RETURN (NOPE);
05802 }
05803
05804
05805 SUMA_LH("Searching for plane in list");
05806 Found = NOPE;
05807 Elm = NULL;
05808 do {
05809 if (!Elm) Elm = dlist_head(list);
05810 else Elm = Elm->next;
05811 OvD = (SUMA_OVERLAY_LIST_DATUM *) Elm->data;
05812 if (OvD->Overlay == Overlay) Found = YUP;
05813 }while (Elm != dlist_tail(list) && !Found);
05814
05815 if (!Found) {
05816 SUMA_S_Err("Strange, real strange.");
05817 SUMA_RETURN(NOPE);
05818 }
05819
05820 SUMA_LH("Found element, inserting at new position");
05821 if (Elm != dlist_tail(list)) {
05822
05823 dlist_ins_next (list, Elm->next, Elm->data);
05824
05825 dlist_remove (list, Elm, (void *)(&OvD));
05826 } else {
05827 SUMA_LH("Reached the top");
05828 }
05829
05830 SUMA_LH("Compacting");
05831
05832 SUMA_ListOrderToPlaneOrder (list);
05833
05834
05835 SUMA_LH("Clean up");
05836 dlist_destroy(list); SUMA_free(list);
05837 SUMA_RETURN(YUP);
05838 }
05839
05840
05841
05842
05843 SUMA_Boolean SUMA_MovePlaneDown (SUMA_SurfaceObject *SO, char *Name)
05844 {
05845 static char FuncName[]={"SUMA_MovePlaneDown"};
05846 SUMA_OVERLAYS *Overlay=NULL;
05847 SUMA_OVERLAY_LIST_DATUM *OvD=NULL;
05848 DList *list=NULL;
05849 DListElmt *Elm = NULL;
05850 int junk=0;
05851 SUMA_Boolean Found = NOPE, LocalHead = NOPE;
05852
05853 SUMA_ENTRY;
05854
05855
05856 SUMA_LH("Searching for plane");
05857 if (!(Overlay = SUMA_Fetch_OverlayPointer(SO->Overlays, SO->N_Overlays, Name, &junk))) {
05858 SUMA_S_Err("Plane does not exist in SO->Overlays. (identified by name)");
05859 SUMA_RETURN (NOPE);
05860 }
05861
05862
05863 SUMA_LH("Creating list");
05864 if (Overlay->isBackGrnd) list = SUMA_OverlaysToOrderedList (SO, -1);
05865 else list = SUMA_OverlaysToOrderedList (SO, 1);
05866 if (!list) {
05867 SUMA_S_Err("NULL list");
05868 SUMA_RETURN (NOPE);
05869 }
05870
05871
05872 SUMA_LH("Searching for plane in list");
05873 Found = NOPE;
05874 Elm = NULL;
05875 do {
05876 if (!Elm) Elm = dlist_head(list);
05877 else Elm = Elm->next;
05878 OvD = (SUMA_OVERLAY_LIST_DATUM *) Elm->data;
05879 if (OvD->Overlay == Overlay) Found = YUP;
05880 }while (Elm != dlist_tail(list) && !Found);
05881
05882 if (!Found) {
05883 SUMA_S_Err("Strange, real strange.");
05884 SUMA_RETURN(NOPE);
05885 }
05886
05887 SUMA_LH("Found element, inserting at new position");
05888 if (Elm != dlist_head(list)) {
05889
05890 dlist_ins_prev (list, Elm->prev, Elm->data);
05891
05892 dlist_remove (list, Elm, (void *)(&OvD));
05893 } else {
05894 SUMA_LH("Reached the bottom");
05895 }
05896
05897 SUMA_LH("Compacting");
05898
05899 SUMA_ListOrderToPlaneOrder (list);
05900
05901
05902 SUMA_LH("Clean up");
05903 dlist_destroy(list); SUMA_free(list);
05904 SUMA_RETURN(YUP);
05905 }
05906
05907
05908
05909
05910
05911
05912
05913
05914
05915 SUMA_Boolean SUMA_AddNewPlane (SUMA_SurfaceObject *SO, SUMA_OVERLAYS *Overlay, SUMA_DO *dov, int N_dov, int DuplicateFlag)
05916 {
05917 static char FuncName[]={"SUMA_AddNewPlane"};
05918 DList *ForeList=NULL, *BackList = NULL;
05919 SUMA_OVERLAY_LIST_DATUM *OvD=NULL;
05920 int junk=0, i, OverInd;
05921 SUMA_SurfaceObject *SO2 = NULL;
05922 SUMA_Boolean LocalHead = NOPE;
05923
05924 SUMA_ENTRY;
05925
05926 if (!Overlay) {
05927 SUMA_S_Err("You sent me NULLS!");
05928 SUMA_RETURN (NOPE);
05929 }
05930
05931 if (SUMA_isOverlayOfSO(SO, Overlay)) {
05932 if (DuplicateFlag == 0) {
05933 SUMA_S_Err("Plane exists in SO->Overlays.");
05934 SUMA_RETURN (NOPE);
05935 } else {
05936 SUMA_S_Warn("Plane exists in SO->Overlays. Preserving old one.");
05937 SUMA_RETURN (YUP);
05938 }
05939 }
05940
05941
05942 if (SUMA_Fetch_OverlayPointer(SO->Overlays, SO->N_Overlays, Overlay->Name, &junk)) {
05943 if (DuplicateFlag == 0) {
05944 SUMA_S_Err("Plane exists in SO->Overlays (identified by name).");
05945 SUMA_RETURN (NOPE);
05946 } else {
05947 SUMA_S_Warn("Plane exists in SO->Overlays (identified by name). Preserving old one.");
05948 SUMA_RETURN (YUP);
05949 }
05950 }
05951
05952
05953 if (Overlay->OptScl) {
05954 if (Overlay->OptScl->BiasVect) {
05955 SUMA_SL_Err("New overlay plane cannot have coordinate bias.\nNot yet at least.\n");
05956
05957
05958
05959
05960 SUMA_RETURN(NOPE);
05961 }
05962 }
05963
05964 if (SO->N_Overlays+1 >= SUMA_MAX_OVERLAYS) {
05965 SUMA_SL_Crit("Too many color overlays.");
05966 SUMA_RETURN (NOPE);
05967 }
05968
05969
05970 if (!(ForeList = SUMA_OverlaysToOrderedList (SO, 1))) {
05971 SUMA_S_Err("NULL ForeList");
05972 SUMA_RETURN (NOPE);
05973 }
05974 if (!(BackList = SUMA_OverlaysToOrderedList (SO, -1))) {
05975 SUMA_S_Err("NULL BackList");
05976 SUMA_RETURN (NOPE);
05977 }
05978
05979 SUMA_LH("Adding to list...");
05980 OvD = (SUMA_OVERLAY_LIST_DATUM *) SUMA_malloc(sizeof(SUMA_OVERLAY_LIST_DATUM));
05981 OvD->Overlay = Overlay;
05982
05983 if (Overlay->isBackGrnd) {
05984 SUMA_LH("Back dude...");
05985 dlist_ins_next(BackList, dlist_tail(BackList), (void *)OvD);
05986 Overlay->PlaneOrder = BackList->size - 1;
05987 } else {
05988 SUMA_LH("Front dude...");
05989 dlist_ins_next(ForeList, dlist_tail(ForeList), (void *)OvD);
05990 Overlay->PlaneOrder = ForeList->size - 1;
05991 }
05992
05993 SUMA_LH("Out dude...");
05994
05995 SO->Overlays[SO->N_Overlays] = Overlay;
05996
05997 ++SO->N_Overlays;
05998
05999
06000 SUMA_LH("Destruction...");
06001 dlist_destroy(ForeList); SUMA_free(ForeList);
06002 dlist_destroy(BackList); SUMA_free(BackList);
06003
06004
06005 if (dov) {
06006 SUMA_LH("Registering plane with surfaces deserving it");
06007
06008
06009 for (i=0; i < N_dov; ++i) {
06010 if (SUMA_isSO(dov[i])) {
06011 SO2 = (SUMA_SurfaceObject *)dov[i].OP;
06012 if (SUMA_isRelated(SO, SO2, 1) && SO != SO2) {
06013
06014 if (!SUMA_Fetch_OverlayPointer (SO2->Overlays, SO2->N_Overlays, Overlay->Name, &OverInd)) {
06015
06016 SO2->Overlays[SO2->N_Overlays] = (SUMA_OVERLAYS *)SUMA_LinkToPointer((void*)SO->Overlays[SO->N_Overlays-1]);
06017
06018 ++SO2->N_Overlays;
06019 } else {
06020
06021 }
06022 }
06023 }
06024 }
06025 }
06026 SUMA_RETURN (YUP);
06027 }
06028
06029
06030
06031
06032
06033
06034
06035 SUMA_Boolean SUMA_MixColors (SUMA_SurfaceViewer *sv)
06036 {
06037 static char FuncName[]={"SUMA_MixColors"};
06038 int i, dov_id;
06039 SUMA_Boolean LocalHead = NOPE;
06040 SUMA_SurfaceObject *SO = NULL;
06041
06042 SUMA_ENTRY;
06043
06044 for (i=0; i<sv->N_ColList; ++i) {
06045 if (sv->ColList[i].Remix) {
06046 if (LocalHead) fprintf(SUMA_STDERR, "%s: Mixing colors (%s)...\n", FuncName, sv->ColList[i].idcode_str);
06047 dov_id = SUMA_findSO_inDOv (sv->ColList[i].idcode_str, SUMAg_DOv, SUMAg_N_DOv);
06048 if (dov_id < 0) {
06049 fprintf (SUMA_STDERR,"Error %s: Failed in SUMA_findSO_inDOv.\n", FuncName);
06050 SUMA_RETURN(NOPE);
06051 }
06052 SO = (SUMA_SurfaceObject *)SUMAg_DOv[dov_id].OP;
06053 if (!SUMA_Overlays_2_GLCOLAR4(SO, sv, sv->ColList[i].glar_ColorList)) {
06054 fprintf (SUMA_STDERR,"Error %s: Failed in SUMA_Overlays_2_GLCOLAR4.\n", FuncName);
06055 SUMA_RETURN(NOPE);
06056 }
06057 sv->ColList[i].Remix = NOPE;
06058 }
06059 }
06060
06061 SUMA_RETURN (YUP);
06062
06063 }
06064
06065
06066
06067
06068
06069
06070
06071
06072
06073
06074
06075
06076
06077
06078
06079
06080
06081 SUMA_Boolean SUMA_iRGB_to_OverlayPointer (SUMA_SurfaceObject *SO,
06082 char *Name, SUMA_OVERLAY_PLANE_DATA *sopd,
06083 int *PlaneInd, SUMA_DO *dov, int N_dov,
06084 DList *DsetList)
06085 {
06086 static char FuncName[]={"SUMA_iRGB_to_OverlayPointer"}, stmp[500];
06087 char *DsetName_tmp=NULL;
06088 int i, OverInd = -1, i_max, wrn_cnt = 0, i3 = 0, N_NodeDef = -1, *NodeDef = NULL;
06089 SUMA_SurfaceObject *SO2 = NULL;
06090 SUMA_OVERLAYS *Overlay=NULL;
06091 SUMA_DSET *dset = NULL;
06092 SUMA_Boolean LocalHead = NOPE;
06093
06094 SUMA_ENTRY;
06095
06096 SUMA_LH("Fetching Overlay Pointer");
06097
06098 if (!SUMA_Fetch_OverlayPointer (SO->Overlays, SO->N_Overlays, Name, &OverInd)) {
06099 SUMA_LH("pointer not found");
06100
06101 if (!SUMA_isLocalDomainParent(SO)) {
06102 if (sopd->Source == SES_Afni) {
06103
06104 fprintf(SUMA_STDERR,"Error %s: Surface %s (ID: %s) received from AFNI is not a local domain parent.\n", FuncName, SO->Label, SO->idcode_str);
06105 SUMA_RETURN(NOPE);
06106 } else {
06107 SUMA_SL_Warn ("Placing colors on surface \nnot a local domain parent.\nCase not tested.");
06108 }
06109 }
06110
06111 DsetName_tmp = SUMA_append_string(Name, SO->LocalDomainParentID);
06112 dset = SUMA_CreateDsetPointer (DsetName_tmp,
06113 SUMA_NODE_RGB,
06114 NULL,
06115 SO->idcode_str,
06116 SO->N_Node);
06117 SUMA_free(DsetName_tmp); DsetName_tmp = NULL;
06118
06119 if (!SUMA_InsertDsetPointer(dset, DsetList)) {
06120 SUMA_SL_Err("Failed to insert dset into list");
06121 SUMA_RETURN(NOPE);
06122 }
06123
06124 SUMA_AddDsetNelCol (dset, "node index", SUMA_NODE_INDEX, NULL, NULL, 1);
06125 SUMA_AddDsetNelCol (dset, "red", SUMA_NODE_R, NULL, NULL, 1);
06126 SUMA_AddDsetNelCol (dset, "green", SUMA_NODE_G, NULL, NULL, 1);
06127 SUMA_AddDsetNelCol (dset, "blue", SUMA_NODE_B, NULL, NULL, 1);
06128
06129 Overlay = SUMA_CreateOverlayPointer (SO->N_Node, Name, dset, SO->idcode_str);
06130 if (!Overlay) {
06131 fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_CreateOverlayPointer.\n", FuncName);
06132 SUMA_RETURN(NOPE);
06133 }
06134
06135
06136
06137 Overlay->Show = sopd->Show;
06138 Overlay->GlobalOpacity = sopd->GlobalOpacity;
06139 Overlay->isBackGrnd = sopd->isBackGrnd;
06140 Overlay->OptScl->BrightFact = sopd->DimFact;
06141 OverInd = SO->N_Overlays;
06142
06143
06144 if (!SUMA_AddNewPlane (SO, Overlay, dov, N_dov, 0)) {
06145 SUMA_SL_Crit("Failed in SUMA_AddNewPlane");
06146 SUMA_FreeOverlayPointer(Overlay);
06147 SUMA_RETURN (NOPE);
06148 }
06149
06150
06151 }else {
06152 SUMA_LH("Pointer found");
06153 }
06154
06155 if (LocalHead) fprintf (SUMA_STDERR, "%s: OverInd = %d, Loading colors to Overlay Plane...\n", FuncName, OverInd);
06156 if (sopd->N > SO->N_Node) {
06157 sprintf(stmp,"Number of nodes in colorplane (%d)\n" \
06158 "is larger than number of nodes in surface (%d)\n" \
06159 "Proceed if you know what you're doing.\n" \
06160 "Data from high node indices will be ignored.",
06161 sopd->N, SO->N_Node);
06162 SUMA_SLP_Warn(stmp);
06163 i_max = SO->N_Node;
06164 } else {
06165 i_max = sopd->N;
06166 }
06167
06168 SO->Overlays[OverInd]->DimFact = sopd->DimFact;
06169 SO->Overlays[OverInd]->cmapname = SUMA_copy_string("explicit");
06170 SO->Overlays[OverInd]->FullList = 0;
06171
06172
06173 if (LocalHead) fprintf (SUMA_STDERR,
06174 "%s: %d node colors are to be inserted.\n",
06175 FuncName, i_max);
06176
06177 COLP_N_NODEDEF(SO->Overlays[OverInd]) = i_max;
06178 SO->Overlays[OverInd]->dset_link->dnel->vec_filled = i_max;
06179
06180
06181 if (COLP_N_NODEDEF(SO->Overlays[OverInd])) {
06182 int *iv, N_i,*Nv;
06183 float *Rv, *Gv, *Bv;
06184 SUMA_DSET *dset;
06185 dset = SO->Overlays[OverInd]->dset_link;
06186
06187
06188 iv = SUMA_GetDsetColIndex (dset, SUMA_NODE_INDEX, &N_i);
06189 if (N_i != 1) { SUMA_SL_Err("Failed to find one column."); SUMA_free(iv); SUMA_RETURN(NOPE); }
06190 Nv = (int *)dset->dnel->vec[iv[0]]; SUMA_free(iv); iv = NULL;
06191 iv = SUMA_GetDsetColIndex (dset, SUMA_NODE_R, &N_i);
06192 if (N_i != 1) { SUMA_SL_Err("Failed to find one column."); SUMA_free(iv); SUMA_RETURN(NOPE); }
06193 Rv = (float *)dset->dnel->vec[iv[0]];SUMA_free(iv); iv = NULL;
06194 iv = SUMA_GetDsetColIndex (dset, SUMA_NODE_G, &N_i);
06195 if (N_i != 1) { SUMA_SL_Err("Failed to find one column."); SUMA_free(iv); SUMA_RETURN(NOPE); }
06196 Gv = (float *)dset->dnel->vec[iv[0]];SUMA_free(iv); iv = NULL;
06197 iv = SUMA_GetDsetColIndex (dset, SUMA_NODE_B, &N_i);
06198 if (N_i != 1) { SUMA_SL_Err("Failed to find one column."); SUMA_free(iv); SUMA_RETURN(NOPE); }
06199 Bv = (float *)dset->dnel->vec[iv[0]];SUMA_free(iv); iv = NULL;
06200
06201 switch (sopd->Type) {
06202 case SOPT_ibbb:
06203 {
06204 int *inel=NULL;
06205 byte *r=NULL, *g=NULL, *b=NULL, *a=NULL;
06206
06207 inel = (int *)sopd->i;
06208 r = (byte *)sopd->r;
06209 g = (byte *)sopd->g;
06210 b = (byte *)sopd->b;
06211 for (i=0; i < i_max; ++i) {
06212
06213 if (SO->N_Node > inel[i]) {
06214 Nv[i] = inel[i];
06215 Rv[i] = (float)(r[i]) / 255.0;
06216 Gv[i] = (float)(g[i]) / 255.0;
06217 Bv[i] = (float)(b[i]) / 255.0;
06218 } else {
06219 if (!wrn_cnt) {
06220 sprintf(stmp, "Color plane includes node indices (%d at %d)\n" \
06221 "that are >= number of nodes in surface (%d).\n"\
06222 "Other similar warnings will be muted.", inel[i], i, SO->N_Node);
06223 SUMA_SLP_Warn(stmp);
06224 }
06225 ++wrn_cnt;
06226 }
06227 }
06228 }
06229 break;
06230 case SOPT_ifff:
06231 {
06232 int *inel=NULL;
06233 float *r=NULL, *g=NULL, *b=NULL, *a=NULL;
06234
06235 inel = (int *)sopd->i;
06236 r = (float *)sopd->r;
06237 g = (float *)sopd->g;
06238 b = (float *)sopd->b;
06239 for (i=0; i < i_max; ++i) {
06240
06241 if (SO->N_Node > inel[i]) {
06242 Nv[i] = inel[i];
06243 Rv[i] = (float)(r[i]) ;
06244 Gv[i] = (float)(g[i]) ;
06245 Bv[i] = (float)(b[i]) ;
06246 } else {
06247 if (!wrn_cnt) {
06248 SUMA_SLP_Warn("Color plane includes node indices\n" \
06249 "that are >= number of nodes in surface.\n");
06250 }
06251 ++wrn_cnt;
06252 }
06253 }
06254 }
06255 break;
06256 default:
06257 SUMA_SLP_Err("Unknown color plane type");
06258 SUMA_RETURN(NOPE);
06259 break;
06260 }
06261 }
06262
06263
06264 if (!SUMA_ColorizePlane (SO->Overlays[OverInd])) {
06265 SUMA_SLP_Err("Failed to colorize plane.\n");
06266 SUMA_RETURN(NOPE);
06267 }
06268
06269
06270 if (LocalHead) fprintf (SUMA_STDERR, "%s: OverInd = %d. Returning.\n", FuncName, OverInd);
06271 *PlaneInd = OverInd;
06272
06273 SUMA_RETURN (YUP);
06274
06275 }
06276
06277
06278
06279
06280
06281
06282
06283 SUMA_Boolean SUMA_FlushPlaneNotInUse (char *PlaneName, SUMA_SurfaceObject *SO, SUMA_DO *dov, int N_dov)
06284 {
06285 static char FuncName[]={"SUMA_FlushPlaneNotInUse"};
06286 SUMA_DRAWN_ROI *D_ROI = NULL;
06287 int i, OverInd;
06288 SUMA_Boolean LocalHead = NOPE;
06289
06290 SUMA_ENTRY;
06291
06292 if (!PlaneName) SUMA_RETURN(YUP);
06293
06294
06295 for (i=0; i < N_dov; ++i) {
06296 switch (dov[i].ObjectType) {
06297 case ROIdO_type:
06298 D_ROI = (SUMA_DRAWN_ROI *)dov[i].OP;
06299 break;
06300 default:
06301 D_ROI = NULL;
06302 break;
06303 }
06304 if (D_ROI && SUMA_isdROIrelated (D_ROI, SO)) {
06305 if (strcmp(PlaneName, D_ROI->ColPlaneName) == 0) {
06306
06307 SUMA_RETURN (YUP);
06308 }
06309 }
06310 }
06311
06312
06313 if (!SUMA_Fetch_OverlayPointer (SO->Overlays, SO->N_Overlays, PlaneName, &OverInd)) {
06314 SUMA_SLP_Warn("No Overlay Plane Found!");
06315 SUMA_RETURN (YUP);
06316 }
06317
06318 SUMA_LH("Flushing meadows");
06319 #if 0
06320 SO->Overlays[OverInd]->N_NodeDef = 0;
06321 #else
06322 COLP_N_NODEDEF(SO->Overlays[OverInd]) = 0;
06323 #endif
06324 SUMA_RETURN (YUP);
06325 }
06326
06327
06328
06329
06330
06331
06332 void SUMA_RefreshDsetList (SUMA_SurfaceObject *SO)
06333 {
06334 static char FuncName[]={"SUMA_RefreshDsetList"};
06335 SUMA_LIST_WIDGET *LW = NULL;
06336 SUMA_Boolean LocalHead = NOPE;
06337
06338 SUMA_ENTRY;
06339
06340 LW = SO->SurfCont->SwitchDsetlst;
06341
06342 if (!LW) SUMA_RETURNe;
06343
06344 if (LW->ALS) {
06345
06346 if (LocalHead) SUMA_S_Err("Freeing the hag.");
06347 LW->ALS = SUMA_FreeAssembleListStruct(LW->ALS);
06348 }
06349
06350
06351
06352 LW->ALS = SUMA_AssembleColorPlaneList (SO);
06353
06354 if (!LW->ALS) {
06355 SUMA_SLP_Err("Error assembling list.");
06356 SUMA_RETURNe;
06357 }
06358
06359 if (LW->ALS->N_clist < 0) {
06360 SUMA_SL_Err("Failed in SUMA_AssembleColorPlaneList");
06361 SUMA_RETURNe;
06362 }
06363
06364 if (!LW->ALS->N_clist) {
06365 SUMA_SLP_Note ("No Color planes to choose from.");
06366 SUMA_RETURNe;
06367 }
06368
06369 if (LocalHead) {
06370 int i;
06371 for (i=0; i < LW->ALS->N_clist; ++i) fprintf (SUMA_STDERR,"%s: %s\n", FuncName, LW->ALS->clist[i]);
06372 }
06373 SUMA_CreateScrolledList ( LW->ALS->clist, LW->ALS->N_clist, NOPE,
06374 LW);
06375
06376 SUMA_RETURNe;
06377 }
06378
06379
06380
06381
06382
06383
06384
06385
06386
06387
06388
06389
06390 SUMA_ASSEMBLE_LIST_STRUCT * SUMA_AssembleColorPlaneList (SUMA_SurfaceObject *SO)
06391 {
06392 static char FuncName[]={"SUMA_AssembleColorPlaneList"};
06393 int i=-1, N_clist=-1;
06394 DList *list=NULL, *listop = NULL, *OverlayPlanelist = NULL;
06395 DListElmt *Elm = NULL, *Elmop = NULL, *Elm_OverlayPlanelist = NULL;
06396 char Label[SUMA_MAX_NAME_LENGTH], *store=NULL;
06397 char **clist=NULL;
06398 void **oplist=NULL;
06399 SUMA_ASSEMBLE_LIST_STRUCT *clist_str = NULL;
06400 SUMA_OVERLAY_LIST_DATUM *OvD=NULL, *oOvD=NULL;
06401 SUMA_Boolean SortByOrder = YUP;
06402 SUMA_Boolean Found = NOPE;
06403 SUMA_Boolean LocalHead = NOPE;
06404
06405 SUMA_ENTRY;
06406
06407
06408 OverlayPlanelist = SUMA_OverlaysToOrderedList (SO, 0);
06409
06410
06411 list = (DList *)SUMA_malloc(sizeof(DList));
06412 dlist_init(list, NULL);
06413
06414 listop = (DList *)SUMA_malloc(sizeof(DList));
06415 dlist_init(listop, NULL);
06416
06417 clist = NULL;
06418 N_clist = -1;
06419 Elm_OverlayPlanelist = NULL;
06420 do {
06421 if (!Elm_OverlayPlanelist) Elm_OverlayPlanelist = dlist_head(OverlayPlanelist);
06422 else Elm_OverlayPlanelist = Elm_OverlayPlanelist->next;
06423
06424 OvD = (SUMA_OVERLAY_LIST_DATUM *) Elm_OverlayPlanelist->data;
06425
06426 if (!OvD->Overlay->Label) sprintf (Label,"NULL");
06427 else sprintf (Label,"%s", OvD->Overlay->Label);
06428
06429 SUMA_LH(Label);
06430
06431 store = (char *)SUMA_calloc(strlen(Label)+10, sizeof(char));
06432 if (OvD->Overlay->isBackGrnd) {
06433 sprintf(store,"bk:%s", Label);
06434 } else {
06435 sprintf(store,"fg:%s", Label);
06436 }
06437
06438 if (SortByOrder) {
06439 SUMA_LH("Sorting by order");
06440
06441 dlist_ins_next(list, dlist_tail(list), (void*)store);
06442
06443 dlist_ins_next(listop, dlist_tail(listop), (void*)OvD);
06444 } else {
06445 SUMA_LH("Sorting by name");
06446 if (!list->size) {
06447 dlist_ins_next(list, dlist_tail(list), (void*)store);
06448 dlist_ins_next(listop, dlist_tail(listop), (void*)OvD);
06449 }else {
06450 Elm = NULL;
06451 Elmop = NULL;
06452 do {
06453 Found = NOPE;
06454 if (!Elm) {
06455 Elm = dlist_head(list);
06456 Elmop = dlist_head(listop);
06457 } else {
06458 Elm = Elm->next;
06459 Elmop = Elmop->next;
06460 }
06461
06462 if (strcmp(store, (char*)Elm->data) <= 0) {
06463 dlist_ins_prev(list, Elm, (void *)store);
06464 dlist_ins_prev(listop, Elmop, (void *)OvD);
06465 Found = YUP;
06466 } else if (Elm == dlist_tail(list)) {
06467
06468 dlist_ins_next(list, Elm, (void *)store);
06469 dlist_ins_next(listop, Elmop, (void *)OvD);
06470 Found = YUP;
06471 }
06472 } while (!Found);
06473 }
06474
06475 }
06476 } while (Elm_OverlayPlanelist != dlist_tail(OverlayPlanelist));
06477
06478 SUMA_LH("saving list.");
06479 if (!list->size) {
06480 SUMA_LH("Empty list");
06481 N_clist = 0;
06482 }else {
06483 Elm = NULL;
06484 Elmop = NULL;
06485 clist = (char **)SUMA_calloc(list->size, sizeof(char *));
06486 oplist = (void **)SUMA_calloc(list->size, sizeof(void *));
06487 for (i=0; i< list->size; ++i) {
06488 if (!Elm) {
06489 Elm = dlist_head(list);
06490 Elmop = dlist_head(listop);
06491 } else {
06492 Elm = dlist_next(Elm);
06493 Elmop = dlist_next(Elmop);
06494 }
06495 clist[i] = (char*)Elm->data;
06496 OvD = (SUMA_OVERLAY_LIST_DATUM *) Elmop->data;
06497 oplist[i] = (void *)OvD->Overlay;
06498 if (LocalHead) fprintf (SUMA_STDERR,"%s: Inserting %s with %s (%s).\n",
06499 FuncName, clist[i], OvD->Overlay->Label, OvD->Overlay->Name);
06500 }
06501
06502 N_clist = list->size;
06503
06504 dlist_destroy(list);
06505 dlist_destroy(listop);
06506 dlist_destroy(OverlayPlanelist);
06507 SUMA_free(list);
06508 SUMA_free(listop);
06509 SUMA_free(OverlayPlanelist);
06510 }
06511
06512 clist_str = SUMA_CreateAssembleListStruct();
06513 clist_str->clist = clist;
06514 clist_str->oplist = oplist;
06515 clist_str->N_clist = N_clist;
06516
06517
06518 SUMA_RETURN (clist_str);
06519 }
06520
06521
06522
06523
06524 SUMA_Boolean SUMA_isDsetRelated(SUMA_DSET *dset, SUMA_SurfaceObject *SO)
06525 {
06526 static char FuncName[]={"SUMA_isDsetRelated"};
06527 char *mp = NULL;
06528 int lmp = 0;
06529 SUMA_ENTRY;
06530
06531 if (!dset) SUMA_RETURN(NOPE);
06532 if (!SO) SUMA_RETURN(NOPE);
06533
06534 mp = SDSET_IDMDOM(dset); if (mp) lmp = strlen(mp); else lmp = 0;
06535
06536 if (mp && lmp) {
06537 if (strcmp(mp, SO->idcode_str) == 0) SUMA_RETURN(YUP);
06538 if (SO->DomainGrandParentID) {
06539 if (strcmp(mp, SO->DomainGrandParentID) == 0) SUMA_RETURN(YUP);
06540 }
06541 if (SO->LocalDomainParentID) {
06542 if (strcmp(mp, SO->LocalDomainParentID) == 0) SUMA_RETURN(YUP);
06543 }
06544 }
06545
06546 SUMA_RETURN(NOPE);
06547 }
06548
06549 SUMA_Boolean SUMA_isDsetColumn_inferred(SUMA_DSET *dset, int icol)
06550 {
06551 static char FuncName[]={"SUMA_isDsetColumn_inferred"};
06552 char *lblcp=NULL;
06553 SUMA_Boolean LocalHead = NOPE;
06554 SUMA_ENTRY;
06555
06556 lblcp = SUMA_DsetColLabelCopy(dset, icol, 0);
06557
06558 SUMA_LH(lblcp);
06559 if (lblcp) {
06560 if (strstr(lblcp, "(inferred)")) SUMA_RETURN(YUP);
06561 }
06562 SUMA_free(lblcp);
06563 SUMA_RETURN(NOPE);
06564 }
06565
06566
06567 SUMA_Boolean SUMA_AddNodeIndexColumn(SUMA_DSET *dset, SUMA_SurfaceObject *SO)
06568 {
06569 static char FuncName[]={"SUMA_AddNodeIndexColumn"};
06570 float range[2];
06571 int *iv=NULL, i, N_i;
06572 float *T = NULL;
06573 int *Ti = NULL;
06574 SUMA_Boolean OKfirstCol = NOPE;
06575 SUMA_Boolean LocalHead = NOPE;
06576
06577 SUMA_ENTRY;
06578
06579 if (!dset) SUMA_RETURN(NOPE);
06580 if (!SO) SUMA_RETURN(NOPE);
06581
06582 if (dset->dnel->vec_len > SO->N_Node) {
06583 SUMA_SL_Err("more values in dset than nodes in surface.");
06584 SUMA_RETURN(NOPE);
06585 }
06586
06587 iv = SUMA_GetDsetColIndex (dset, SUMA_NODE_INDEX, &N_i);
06588 if (!iv) {
06589 SUMA_LH("No node index column");
06590
06591 T = SUMA_DsetCol2Float (dset, 0, 0);
06592 OKfirstCol = NOPE;
06593 if (!T) { SUMA_LH("First column does not cut it"); OKfirstCol = NOPE;}
06594 else {
06595 Ti = (int *)SUMA_malloc(sizeof(int)*dset->dnel->vec_len);
06596 SUMA_LH("Testing if node indices can be in 1st column...");
06597
06598 i=0;
06599 OKfirstCol = YUP;
06600 while (i <dset->dnel->vec_len && OKfirstCol) {
06601 Ti[i] = (int)T[i];
06602 if ( (T[i] != Ti[i]) || (T[i] < 0) || (T[i] >= SO->N_Node) ) OKfirstCol = NOPE;
06603 ++i;
06604 }
06605
06606 if (!OKfirstCol) {
06607 SUMA_SLP_Note( "Assuming node indexing\n"
06608 "is explicit. \n"
06609 "1st row is for node 0\n"
06610 "2nd is for node 1, etc.\n" );
06611 for (i=0; i <dset->dnel->vec_len; ++i) Ti[i]=i;
06612 OKfirstCol = YUP;
06613 }else{
06614 char Name[500], Attr[500];
06615 SUMA_SLP_Note("Used column 0 as node indices.\nAdded a node index column nonetheless.");
06616
06617
06618 }
06619
06620 }
06621
06622 if (!OKfirstCol) {
06623 SUMA_LH("No node index could be created");
06624 if (Ti) SUMA_free(Ti); Ti = NULL;
06625 SUMA_RETURN(NOPE);
06626 }
06627
06628
06629
06630
06631 if (!SUMA_AddDsetNelCol (dset, "Node Index (inferred)", SUMA_NODE_INDEX, (void *)Ti, NULL, 1)) {
06632 SUMA_SL_Err("Failed to add column");
06633 if (Ti) SUMA_free(Ti); Ti = NULL;
06634 SUMA_RETURN(NOPE);
06635 }
06636
06637
06638 SUMA_LH("Added the index column, ciao");
06639 if (Ti) SUMA_free(Ti); Ti = NULL;
06640 SUMA_RETURN(YUP);
06641 } else {
06642 SUMA_LH("Node index column found");
06643 SUMA_free(iv); iv = NULL;
06644
06645 SUMA_RETURN(YUP);
06646 }
06647
06648 SUMA_SL_Err("why are you here ?");
06649 SUMA_RETURN(NOPE);
06650 }
06651
06652
06653
06654 SUMA_Boolean SUMA_OKassign(SUMA_DSET *dset, SUMA_SurfaceObject *SO)
06655 {
06656 static char FuncName[]={"SUMA_OKassign"};
06657 float range[2];
06658 int loc[2], *iv=NULL, N_i, lnp = 0;
06659 char *np = NULL, stmp[201];
06660 SUMA_Boolean LocalHead = NOPE;
06661
06662 SUMA_ENTRY;
06663
06664 if (!dset) SUMA_RETURN(NOPE);
06665 if (!SO) SUMA_RETURN(NOPE);
06666
06667
06668 np = SDSET_IDMDOM(dset); if (np) lnp = strlen(np); else lnp = 0;
06669 if (np && lnp) {
06670 SUMA_LH("Has IDMDOM");
06671
06672 if (SUMA_isDsetRelated(dset, SO)) { SUMA_LH("Is Related"); SUMA_RETURN(YUP); }
06673 else { SUMA_LH("Is NOT Related"); SUMA_RETURN(NOPE); }
06674 }
06675
06676 SUMA_LH("Has no parent, trying adoption");
06677
06678 iv = SUMA_GetDsetColIndex (dset, SUMA_NODE_INDEX, &N_i);
06679 if (!iv) {
06680 SUMA_LH("No node index column");
06681
06682 if (dset->dnel->vec_len <= SO->N_Node) {
06683 SUMA_LH("Number of values per column\n"
06684 "is less than the number \n"
06685 "of nodes in the surface.\n");
06686 if (dset->dnel->vec_filled != SO->N_Node) {
06687 SUMA_LH("Need to attach a node index column, if possible");
06688
06689 if (!SUMA_AddNodeIndexColumn(dset, SO)) {
06690 SUMA_LH(" Failed to add a node index column");
06691 SUMA_RETURN(NOPE);
06692 } else {
06693 SUMA_LH("Added Index Column");
06694 SUMA_RETURN(YUP);
06695 }
06696 }else {
06697 SUMA_LH( "Looks like a full list of values\n"
06698 "Techincally, there's no need for explicit node column.\n"
06699 "But at times, the data are not ordered by ascending node \n"
06700 "index which causes trouble.\nSo now I add a node index column"
06701 " always which would help point to the problem if it arises");
06702
06703 if (!SUMA_AddNodeIndexColumn(dset, SO)) {
06704 SUMA_LH(" Failed to add a node index column");
06705 SUMA_RETURN(NOPE);
06706 }
06707 SUMA_LH("Added Index Column");
06708 SUMA_RETURN(YUP);
06709 }
06710 } else {
06711 snprintf(stmp, 200*sizeof(char),
06712 "Number of values per column (%d)\n"
06713 "is larger than the number \n"
06714 "of nodes (%d) in the surface.", dset->dnel->vec_len, SO->N_Node);
06715 SUMA_SLP_Err(stmp);
06716 SUMA_RETURN(NOPE);
06717 }
06718 } else {
06719 SUMA_LH("Node index column found");
06720 if (N_i != 1) { SUMA_SL_Err("No support for multiple\nnode index columns"); SUMA_RETURN(NOPE); }
06721
06722 if (!SUMA_GetDsetColRange(dset, iv[0], range, loc)) {
06723 SUMA_SLP_Err("Unexpect error in SUMA_GetDsetColRange");
06724 SUMA_free(iv); iv = NULL;
06725 SUMA_RETURN(NOPE);
06726 }
06727 if (range[0] < 0 || range[1] > SO->N_Node) {
06728 SUMA_SLP_Err("Node index range outside\n"
06729 "0 and SO->N_Node");
06730 SUMA_free(iv); iv = NULL;
06731 SUMA_RETURN(NOPE);
06732 }
06733
06734 SUMA_RETURN(YUP);
06735 }
06736
06737 SUMA_SL_Err("Should not get here");
06738 SUMA_RETURN(NOPE);
06739 }
06740
06741
06742
06743
06744
06745
06746 void SUMA_LoadDsetFile (char *filename, void *data)
06747 {
06748 static char FuncName[]={"SUMA_LoadDsetFile"};
06749 SUMA_SurfaceObject *SO = NULL;
06750 SUMA_OVERLAY_PLANE_DATA sopd;
06751 SUMA_IRGB *irgb=NULL;
06752 int OverInd = -1, lnp=-1, loc[2];
06753 char *np=NULL;
06754 SUMA_DSET_FORMAT form;
06755 DList *list=NULL;
06756 SUMA_LIST_WIDGET *LW=NULL;
06757 SUMA_DSET *dset = NULL;
06758 SUMA_OVERLAYS *NewColPlane = NULL;
06759 SUMA_Boolean LocalHead = NOPE;
06760
06761 SUMA_ENTRY;
06762
06763 if (!data) {
06764 SUMA_SLP_Err("Null data");
06765 SUMA_RETURNe;
06766 }
06767
06768 SO = (SUMA_SurfaceObject *)data;
06769
06770 if (LocalHead) {
06771 fprintf (SUMA_STDERR,"%s: Received request to load %s for surface %s.\n", FuncName, filename, SO->Label);
06772 }
06773
06774
06775 if (!SUMA_filexists(filename)) {
06776 SUMA_SLP_Err("File not found");
06777 SUMA_RETURNe;
06778 }
06779
06780
06781 form = SUMA_GuessFormatFromExtension(filename);
06782
06783
06784
06785
06786
06787 if (SO->LocalDomainParentID) SUMA_SetParent_DsetToLoad(SO->LocalDomainParentID);
06788 else if (SO->idcode_str) SUMA_SetParent_DsetToLoad(SO->idcode_str);
06789 else SUMA_SetParent_DsetToLoad(NULL);
06790
06791 dset = SUMA_LoadDset (filename, &form, 0);
06792 if (!dset) { SUMA_SLP_Err( "Failed to load dataset.\n"
06793 "Make sure file exists\n"
06794 "and is of a supported\n"
06795 "format."); SUMA_RETURNe; }
06796 SUMA_SetParent_DsetToLoad(NULL);
06797
06798 if (LocalHead) {
06799 char *si = NULL;
06800 si = SUMA_DsetInfo(dset, 0);
06801 fprintf(SUMA_STDERR,"%s:\n----------------dset loaded ----------\n%s\n",FuncName, si);
06802 SUMA_free(si); si = NULL;
06803 }
06804
06805
06806
06807 np = SDSET_IDMDOM(dset); if (np) lnp = strlen(np) ; else lnp = 0;
06808 if (!np || lnp == 0) {
06809 SUMA_SL_Note("dset has no mesh parent, assigning SO");
06810 if (!SUMA_OKassign(dset, SO)) {
06811 SUMA_SLP_Err("Cannot assign dset to SO.\n");
06812 SUMA_FreeDset(dset); dset=NULL;
06813 SUMA_RETURNe;
06814 }
06815 NI_set_attribute(dset->ngr,"Parent_ID", SO->idcode_str);
06816 NI_set_attribute(dset->ngr,"GeomParent_idcode", SO->idcode_str);
06817 } else {
06818 SUMA_SL_Note("dset has a mesh parent, Checking relationship");
06819 if (!SUMA_isDsetRelated(dset, SO)) {
06820 SUMA_SLP_Err("Dset not related to SO");
06821 SUMA_FreeDset(dset); dset=NULL;
06822 SUMA_RETURNe;
06823 }
06824 }
06825
06826
06827 if (!SUMA_InsertDsetPointer(dset, SUMAg_CF->DsetList)) {
06828 SUMA_SLP_Err("Failed to add new dset to list");
06829
06830 SUMA_FreeDset(dset); dset = NULL;
06831 SUMA_RETURNe;
06832 }
06833
06834
06835 NewColPlane = SUMA_CreateOverlayPointer (dset->dnel->vec_len, filename, dset, SO->idcode_str);
06836 if (!NewColPlane) {
06837 fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_CreateOverlayPointer.\n", FuncName);
06838 SUMA_RETURNe;
06839 }
06840
06841
06842 OverInd = SO->N_Overlays;
06843
06844
06845 if (!SUMA_AddNewPlane (SO, NewColPlane, SUMAg_DOv, SUMAg_N_DOv, 0)) {
06846 SUMA_SL_Crit("Failed in SUMA_AddNewPlane");
06847 SUMA_FreeOverlayPointer(NewColPlane);
06848 SUMA_FreeDset(dset); dset = NULL;
06849 SUMA_RETURNe;
06850 }
06851
06852
06853
06854 NewColPlane->GlobalOpacity = YUP;
06855 NewColPlane->Show = YUP;
06856 NewColPlane->OptScl->find = 0;
06857 NewColPlane->OptScl->tind = 0;
06858 NewColPlane->OptScl->bind = 0;
06859 SUMA_GetDsetColRange(dset, 0, NewColPlane->OptScl->IntRange, loc);
06860
06861
06862
06863
06864
06865
06866 SUMA_ColorizePlane(NewColPlane);
06867
06868
06869
06870
06871
06872
06873
06874
06875
06876
06877
06878
06879 SO->SurfCont->curColPlane = SO->Overlays[OverInd];
06880
06881
06882 if (!SUMA_RemixRedisplay (SO)) {
06883 SUMA_RETURNe;
06884 }
06885
06886 SUMA_LH("Refreshing Dset list");
06887
06888 LW = SO->SurfCont->SwitchDsetlst;
06889 if (LW) {
06890 if (!LW->isShaded) SUMA_RefreshDsetList (SO);
06891 }
06892
06893 if (LocalHead) fprintf (SUMA_STDERR,"%s: Updating Dset frame, OverInd=%d\n",
06894 FuncName, OverInd);
06895
06896 if (OverInd >= 0)
06897 SUMA_InitializeColPlaneShell(SO, SO->Overlays[OverInd]);
06898
06899 SUMA_RETURNe;
06900 }
06901
06902
06903
06904
06905
06906
06907 void SUMA_LoadColorPlaneFile (char *filename, void *data)
06908 {
06909 static char FuncName[]={"SUMA_LoadColorPlaneFile"};
06910 SUMA_SurfaceObject *SO = NULL;
06911 SUMA_OVERLAY_PLANE_DATA sopd;
06912 SUMA_IRGB *irgb=NULL;
06913 int OverInd = -1;
06914 DList *list=NULL;
06915 SUMA_LIST_WIDGET *LW=NULL;
06916 SUMA_Boolean LocalHead = NOPE;
06917
06918 SUMA_ENTRY;
06919
06920 if (!data) {
06921 SUMA_SLP_Err("Null data");
06922 SUMA_RETURNe;
06923 }
06924
06925 SO = (SUMA_SurfaceObject *)data;
06926
06927 if (LocalHead) {
06928 fprintf (SUMA_STDERR,"%s: Received request to load %s for surface %s.\n", FuncName, filename, SO->Label);
06929 }
06930
06931
06932 if (!SUMA_filexists(filename)) {
06933 SUMA_SLP_Err("File not found");
06934 SUMA_RETURNe;
06935 }
06936
06937 irgb = SUMA_Read_IRGB_file(filename);
06938 if (!irgb) {
06939 SUMA_SLP_Err("Failed to read file.");
06940 SUMA_RETURNe;
06941 }
06942
06943 sopd.N = irgb->N;
06944 sopd.Type = SOPT_ifff;
06945 sopd.Source = SES_Suma;
06946 sopd.GlobalOpacity = 0.3;
06947 sopd.isBackGrnd = NOPE;
06948 sopd.Show = YUP;
06949
06950 sopd.DimFact = 0.5;
06951 sopd.i = (void *)irgb->i;
06952 sopd.r = (void *)irgb->r;
06953 sopd.g = (void *)irgb->g;
06954 sopd.b = (void *)irgb->b;
06955 sopd.a = NULL;
06956
06957 if (!SUMA_iRGB_to_OverlayPointer ( SO, filename, &sopd, &OverInd,
06958 SUMAg_DOv, SUMAg_N_DOv, SUMAg_CF->DsetList)) {
06959 SUMA_SLP_Err("Failed to fetch or create overlay pointer.");
06960 SUMA_RETURNe;
06961 }
06962
06963
06964 irgb = SUMA_Free_IRGB(irgb);
06965
06966
06967 SO->SurfCont->curColPlane = SO->Overlays[OverInd];
06968
06969 if (!SUMA_RemixRedisplay (SO)) {
06970 SUMA_RETURNe;
06971 }
06972
06973 SUMA_LH("Refreshing color plane list");
06974
06975 LW = SO->SurfCont->SwitchDsetlst;
06976 if (LW) {
06977 if (!LW->isShaded) SUMA_RefreshDsetList (SO);
06978 }
06979
06980 if (LocalHead) fprintf (SUMA_STDERR,"%s: Updating color plane frame, OverInd=%d\n",
06981 FuncName, OverInd);
06982
06983 if (OverInd >= 0)
06984 SUMA_InitializeColPlaneShell(SO, SO->Overlays[OverInd]);
06985
06986 SUMA_RETURNe;
06987 }
06988
06989
06990
06991
06992
06993
06994
06995
06996
06997 #define SUMA_ISTARRED(s) ( (s)[0]=='*' && (s)[1]=='*' && (s)[2]=='*' )
06998
06999 #define SUMA_EOLSKIP \
07000 do{ for( ; fptr[0] != '\n' && fptr[0] != '\0' ; fptr++ ) ; \
07001 if( fptr[0] == '\0' ){ if (fbuf) free(fbuf) ; fbuf = NULL; goto donesection; } \
07002 fptr++ ; } while(0)
07003
07004 #define SUMA_GETSSS \
07005 do{ int nu=0,qq; \
07006 if( fptr-fbuf >= nbuf || fptr[0] == '\0' ){ if (fbuf) free(fbuf); fbuf = NULL; goto donesection; } \
07007 str[0]='\0'; qq=sscanf(fptr,"%127s%n",str,&nu); nused+=nu;fptr+=nu; \
07008 if( str[0]=='\0' || qq==0 || nu==0 ){ if (fbuf) free(fbuf); fbuf = NULL; goto donesection; } \
07009 } while(0)
07010
07011 #define SUMA_GETSTR \
07012 do{ SUMA_GETSSS ; \
07013 while(str[0]=='!' || (str[0]=='/' && str[1]=='/')){SUMA_EOLSKIP; SUMA_GETSSS;} \
07014 } while(0)
07015
07016 #define SUMA_GETEQN \
07017 do{ SUMA_GETSTR ; if(SUMA_ISTARRED(str)) goto SkipSection ; \
07018 strcpy(left,str) ; \
07019 SUMA_GETSTR ; if(SUMA_ISTARRED(str)) goto SkipSection ; \
07020 strcpy(middle,str) ; \
07021 SUMA_GETSTR ; if(SUMA_ISTARRED(str)) goto SkipSection ; \
07022 strcpy(right,str) ; } while(0)
07023
07024 #define SUMA_NSBUF 256
07025
07026
07027
07028
07029
07030
07031
07032
07033
07034
07035
07036
07037
07038
07039
07040
07041
07042 int SUMA_AFNI_Extract_Colors ( char *fname, SUMA_AFNI_COLORS *SAC )
07043 {
07044 static char FuncName[]={"SUMA_AFNI_Extract_Colors"};
07045 int nbuf , nused , ii, ngood = -1;
07046 float rgb[3];
07047 char * fbuf , * fptr ;
07048 char str[SUMA_NSBUF] , left[SUMA_NSBUF] , middle[SUMA_NSBUF] , right[SUMA_NSBUF] ;
07049 SUMA_STRING *SS = NULL;
07050 SUMA_COLOR_MAP *CM=NULL;
07051 SUMA_Boolean LocalHead = NOPE;
07052
07053 fbuf = AFNI_suck_file( fname ) ; if( fbuf == NULL ) {
07054 SUMA_SL_Warn("File could not be read");
07055 SUMA_RETURN(-1) ; }
07056 nbuf = strlen(fbuf) ; if( nbuf == 0 ) {
07057 SUMA_SL_Warn("Empty file");
07058 SUMA_RETURN(-1) ; }
07059
07060 fptr = fbuf ; nused = 0 ;
07061
07062
07063 ngood = 0;
07064
07065 str[0] = '\0' ;
07066
07067 if(LocalHead) {
07068 fprintf(SUMA_STDERR,"Reading AFNI setup file = %s (%d bytes)",fname,nbuf) ;
07069 }
07070
07071 while( nused < nbuf ){
07072
07073
07074
07075
07076 SkipSection: while( ! SUMA_ISTARRED(str) ){ SUMA_GETSTR; SUMA_LH(str);}
07077
07078
07079
07080 if( strcmp(str, "***COLORS") != 0 && strcmp(str, "***PALETTES") != 0){
07081 SUMA_GETSTR ;
07082 goto SkipSection ;
07083 }
07084
07085
07086 SS = SUMA_StringAppend (NULL, NULL);
07087
07088
07089
07090
07091 if( strcmp(str,"***COLORS") == 0 ){
07092 char label[SUMA_NSBUF] , defn[SUMA_NSBUF] ;
07093
07094 if (LocalHead) fprintf (SUMA_STDERR,"%s: Found ***COLORS\n", FuncName);
07095 while(1){
07096 SUMA_GETEQN ;
07097
07098 if (LocalHead) {
07099 fprintf (SUMA_STDERR,"\t %s%s%s\n", left, middle, right);
07100 }
07101
07102
07103
07104 if( !THD_filename_pure(left) ) continue ;
07105
07106 if( strcmp(left,"none")==0 || strcmp(right,"none")==0 ) {
07107 sprintf(left,"none");
07108 rgb[0] = rgb[1] = rgb[2] =-1.0;
07109 } else {
07110 if (!SUMA_Interpret_AFNIColor (right, rgb)) {
07111 fprintf(SUMA_STDERR,"Error %s: Failed to interpret color %s\n", FuncName, right);
07112 SUMA_RETURN(-1);
07113 }
07114 }
07115 SAC->Cv = SUMA_Add_Color (left,
07116 rgb[0], rgb[1], rgb[2], 1.0,
07117 SAC->Cv, &(SAC->N_cols));
07118 }
07119 continue ;
07120 }
07121
07122
07123
07124
07125 if( strcmp(str,"***PALETTES") == 0 ){
07126 char label[SUMA_NSBUF] = "NoThing" , ccc , * cpt ;
07127 PBAR_palette_array * ppar=NULL ;
07128 PBAR_palette ** ppp ;
07129 PBAR_palette * ppnew ;
07130 int npane , pmode , icol=0 , jj ;
07131 float val ;
07132
07133 if (LocalHead) fprintf (SUMA_STDERR,"enter ***PALETTES\n");
07134
07135
07136
07137 while(1){
07138 SUMA_GETSTR ; if( SUMA_ISTARRED(str) ) goto SkipSection ;
07139 if( fptr-fbuf >= nbuf ){ if (fbuf) free(fbuf) ; fbuf = NULL; SUMA_RETURN(-1) ; }
07140
07141 if( str[0] != '[' ){
07142 strcpy(label,str) ;
07143 if( !THD_filename_ok(label) ){
07144 fprintf(SUMA_STDERR,"Error %s: In setup file %s, bad palette label: %s.\n Ignoring palette.\n",
07145 FuncName, fname,label) ;
07146 if (fbuf) free(fbuf) ; fbuf = NULL;
07147 SUMA_RETURN(-1) ;
07148 }
07149
07150 if (LocalHead) {
07151 fprintf (SUMA_STDERR,"%s: found palette label=%s. [len=%d label[0]=%d]\nnbuf=%d fptr-fbuf=%d\n",
07152 FuncName, label,(int)strlen(label),(int)label[0],
07153 nbuf,fptr-fbuf);
07154 }
07155
07156
07157
07158 SUMA_GETSTR ; if( SUMA_ISTARRED(str) ) goto SkipSection ;
07159 }
07160
07161
07162 if( str[0] != '[' ){
07163 fprintf(SUMA_STDERR,"Error %s: In setup file %s, expected palette '[n]' here: %s.\n",
07164 FuncName, fname , str ) ;
07165 SUMA_RETURN(-1) ;
07166 }
07167
07168
07169 ii = sscanf( str , "[%d%c" , &npane , &ccc ) ;
07170 if( ii < 2 ){
07171 fprintf(SUMA_STDERR,"%s: In setup file %s, can't interpret palette %s\n",
07172 FuncName, fname , str ) ;
07173 SUMA_RETURN(-1) ;
07174 } else if( npane < NPANE_MIN || npane > NPANE_MAX ){
07175 fprintf(SUMA_STDERR,"%s: In setup file %s, illegal palette count %s.\n",
07176 FuncName, fname , str ) ;
07177 SUMA_RETURN(-1) ;
07178 }
07179
07180
07181 if (LocalHead) {
07182 fprintf(SUMA_STDERR,"%s: About to read %d panes.\n", FuncName, npane);
07183 }
07184
07185
07186 CM = (SUMA_COLOR_MAP *)SUMA_malloc(sizeof(SUMA_COLOR_MAP));
07187 if (CM == NULL) {
07188 SUMA_SL_Crit ("Failed to allocate for CM");
07189 SUMA_RETURN(-1);
07190 }
07191 CM->SO = NULL;
07192 CM->N_Col = npane;
07193 CM->cname = NULL;
07194
07195 if (ccc == '+') CM->Sgn = 1;
07196 else CM->Sgn = -1;
07197
07198
07199 CM->Name = (char *)SUMA_calloc(strlen(label)+10, sizeof(char));
07200 CM->frac = (float *)SUMA_calloc(CM->N_Col, sizeof(float));
07201 CM->M = (float**)SUMA_allocate2D (CM->N_Col, 3, sizeof(float));
07202 if ( CM->frac == NULL || CM->M == NULL || CM->Name == NULL ) {
07203 SUMA_SL_Crit ("Failed to allocate for fields of CM.");
07204 SUMA_RETURN (-1);
07205 }
07206 if (CM->Sgn == 1) sprintf(CM->Name, "%s_p%d", label, CM->N_Col);
07207 else sprintf(CM->Name, "%s_n%d", label, CM->N_Col);
07208
07209 for( ii=0 ; ii < npane ; ii++ ){
07210 SUMA_GETEQN ;
07211
07212 if (LocalHead) {
07213 fprintf(SUMA_STDERR,"%s: SUMA_GETEQN: %s %s %s\n",FuncName, left,middle,right) ;
07214 }
07215
07216
07217 icol = SUMA_Find_Color (right, SAC->Cv, SAC->N_cols);
07218 if (icol < 0) {
07219 fprintf(SUMA_STDERR,"Error %s: Color %s not found in dbase.\nUsing no-color in its place\n", FuncName, right);
07220 CM->M[npane - ii - 1][0] = CM->M[npane - ii - 1][1] = CM->M[npane - ii - 1][2] = -1.0;
07221 } else {
07222 CM->M[npane - ii - 1][0] = SAC->Cv[icol].r;
07223 CM->M[npane - ii - 1][1] = SAC->Cv[icol].g;
07224 CM->M[npane - ii - 1][2] = SAC->Cv[icol].b;
07225 }
07226 CM->frac[npane - ii - 1] = atof(left);
07227 }
07228
07229 SAC->CMv = SUMA_Add_ColorMap (CM, SAC->CMv, &(SAC->N_maps));
07230 if (SAC->CMv) ++ngood;
07231 continue ;
07232 }
07233 }
07234 SUMA_GETSTR ; goto SkipSection ;
07235
07236 }
07237
07238 donesection:
07239
07240 if (LocalHead) fprintf(SUMA_STDERR,"%s: Returning\n", FuncName);
07241 if (fbuf) free(fbuf) ;
07242 SUMA_RETURN (ngood);
07243
07244 }
07245
07246
07247
07248
07249
07250
07251
07252
07253
07254 SUMA_Boolean SUMA_Interpret_AFNIColor (char *Name, float RGB[3])
07255 {
07256 static char FuncName[]={"SUMA_Interpret_AFNIColor"};
07257 char *vargv[1]={ "SCALE_TO_MAP" };
07258 int cargc = 1;
07259 int r, g, b;
07260 char stmp[10];
07261 XVisualInfo vtmp, *vislist;
07262 XtAppContext app;
07263 Widget tl;
07264 Display *dpy=NULL;
07265 XColor color_closest, color_exact;
07266 Colormap cmap;
07267 SUMA_Boolean LocalHead = NOPE;
07268
07269 SUMA_ENTRY;
07270
07271 if (Name[0] == '#') {
07272 sprintf(stmp,"0x%c%c", Name[1], Name[2]);
07273 sscanf (stmp, "%x", &r);
07274 sprintf(stmp,"0x%c%c", Name[3], Name[4]);
07275 sscanf (stmp, "%x", &g);
07276 sprintf(stmp,"0x%c%c", Name[5], Name[6]);
07277 sscanf (stmp, "%x", &b);
07278 RGB[0] = (float)r/255.0;
07279 RGB[1] = (float)g/255.0;
07280 RGB[2] = (float)b/255.0;
07281
07282 } else {
07283
07284
07285 if (SUMAg_CF->isGraphical) {
07286 tl = XtAppInitialize(NULL, "ScaleToMap", NULL, 0, &cargc, vargv,
07287 SUMA_get_fallbackResources(), NULL, 0);
07288 dpy = XtDisplay(tl);
07289 cmap = DefaultColormap(dpy, DefaultScreen(dpy));
07290
07291 XParseColor(dpy, cmap, Name, &color_exact);
07292
07293
07294
07295 RGB[0] = (float)color_exact.red/255.0/257.0;
07296 RGB[1] = (float)color_exact.green/255.0/257.0;
07297 RGB[2] = (float)color_exact.blue/255.0/257.0;
07298
07299 XFreeColormap(dpy, cmap);
07300 XtDestroyWidget(tl);
07301 } else {
07302 if (LocalHead) fprintf(SUMA_STDERR,"%s: \n"
07303 "Xcolor %s cannot be resolved without \n"
07304 "trying to open X display.\n"
07305 "Returning color 0.5 0.5 0.5", FuncName, Name);
07306 RGB[0] = RGB[1] = RGB[2] = 0.5;
07307 }
07308 }
07309
07310
07311 if (LocalHead) {
07312 fprintf (SUMA_STDERR,"%s: %s = %f %f %f\n",
07313 FuncName, Name, RGB[0], RGB[1], RGB[2]);
07314 }
07315
07316 SUMA_RETURN (YUP);
07317 }
07318
07319
07320
07321
07322 int SUMA_ColorizePlane (SUMA_OVERLAYS *cp)
07323 {
07324 static char FuncName[]={"SUMA_ColorizePlane"};
07325 int i, i3, N_i, *iv, *Nv;
07326 float *Rv, *Bv, *Gv;
07327 SUMA_Boolean LocalHead = NOPE;
07328
07329 SUMA_ENTRY;
07330
07331 if (LocalHead) {
07332 SUMA_LH("Color Plane Pre Colorizing");
07333 SUMA_Show_ColorOverlayPlanes ( &cp, 1, 0);
07334 }
07335 if (!cp) { SUMA_SL_Err("NULL cp"); SUMA_RETURN(NOPE); }
07336 if (!cp->dset_link) { SUMA_SL_Err("Where's your dset_link?"); SUMA_RETURN(NOPE); }
07337 if (!cp->cmapname) { SUMA_SL_Err("Where's your cmapname?"); SUMA_RETURN(NOPE); }
07338 if (!cp->ColVec) { SUMA_SL_Err("NULL cV"); SUMA_RETURN(NOPE); }
07339
07340
07341 if (strcmp(cp->cmapname, "explicit") == 0) {
07342
07343 SUMA_LH("Explicit color specification");
07344
07345 if (SDSET_TYPE(cp->dset_link) != SUMA_NODE_RGB) {
07346 SUMA_SL_Err("Direct mapping is only supported for SUMA_NODE_RGB types");
07347 SUMA_RETURN(NOPE);
07348 }
07349 iv = SUMA_GetDsetColIndex (cp->dset_link, SUMA_NODE_INDEX, &N_i);
07350 if (N_i != 1) { SUMA_SL_Err("Failed to find index column."); SUMA_free(iv); SUMA_RETURN(NOPE); }
07351 Nv = (int *)cp->dset_link->dnel->vec[iv[0]]; SUMA_free(iv); iv = NULL;
07352 iv = SUMA_GetDsetColIndex (cp->dset_link, SUMA_NODE_R, &N_i);
07353 if (N_i != 1) { SUMA_SL_Err("Failed to find red column."); SUMA_free(iv); SUMA_RETURN(NOPE); }
07354 Rv = (float *)cp->dset_link->dnel->vec[iv[0]];SUMA_free(iv); iv = NULL;
07355 iv = SUMA_GetDsetColIndex (cp->dset_link, SUMA_NODE_G, &N_i);
07356 if (N_i != 1) { SUMA_SL_Err("Failed to find green column."); SUMA_free(iv); SUMA_RETURN(NOPE); }
07357 Gv = (float *)cp->dset_link->dnel->vec[iv[0]];SUMA_free(iv); iv = NULL;
07358 iv = SUMA_GetDsetColIndex (cp->dset_link, SUMA_NODE_B, &N_i);
07359 if (N_i != 1) { SUMA_SL_Err("Failed to find blue column."); SUMA_free(iv); SUMA_RETURN(NOPE); }
07360 Bv = (float *)cp->dset_link->dnel->vec[iv[0]];SUMA_free(iv); iv = NULL;
07361
07362
07363 if (LocalHead) {
07364 char *s = NULL;
07365 s = SUMA_DsetInfo(cp->dset_link, 0);
07366 SUMA_S_Note(s);
07367 SUMA_free(s);
07368 }
07369
07370 if (cp->DimFact == 1.0) {
07371 for (i=0; i < cp->dset_link->dnel->vec_filled; ++i) {
07372 i3 = 3 * i;
07373 cp->NodeDef[i] = Nv[i];
07374 cp->ColVec[i3] = Rv[i]; ++i3;
07375 cp->ColVec[i3] = Gv[i]; ++i3;
07376 cp->ColVec[i3] = Bv[i];
07377 }
07378 } else {
07379 for (i=0; i < cp->dset_link->dnel->vec_filled; ++i) {
07380 i3 = 3 * i;
07381 cp->NodeDef[i] = Nv[i];
07382 cp->ColVec[i3] = Rv[i] * cp->DimFact; ++i3;
07383 cp->ColVec[i3] = Gv[i] * cp->DimFact; ++i3;
07384 cp->ColVec[i3] = Bv[i] * cp->DimFact;
07385 }
07386 }
07387 cp->N_NodeDef = cp->dset_link->dnel->vec_filled;
07388 } else {
07389
07390 if (!SUMA_ScaleToMap_Interactive (cp)) {
07391 SUMA_SL_Err("Failed in SUMA_ScaleToMap_Interactive.");
07392 SUMA_RETURN(0);
07393 }
07394
07395 }
07396
07397
07398
07399 if (LocalHead) {
07400 SUMA_LH("Color Plane Post Colorizing");
07401 SUMA_Show_ColorOverlayPlanes ( &cp, 1, 0);
07402 }
07403 SUMA_RETURN(1);
07404 }
07405
07406
07407
07408
07409
07410
07411
07412
07413 SUMA_Boolean SUMA_SetConvexityPlaneDefaults(SUMA_SurfaceObject *SO, DList *DsetList)
07414 {
07415 static char FuncName[]={"SUMA_SetConvexityPlaneDefaults"};
07416 float IntRange[2], *Vsort = NULL;
07417 float *Cx=NULL;
07418 int junk;
07419 char *eee = NULL;
07420 int icmap;
07421 SUMA_OVERLAYS *ConvPlane;
07422 SUMA_Boolean LocalHead = NOPE;
07423
07424 SUMA_ENTRY;
07425
07426 if (!SUMAg_CF->scm) {
07427 SUMAg_CF->scm = SUMA_Build_Color_maps();
07428 if (!SUMAg_CF->scm) {
07429 SUMA_SL_Warn("No color maps set up.\n");
07430 SUMA_RETURN(YUP);
07431 }
07432 }
07433
07434 if (!(ConvPlane = SUMA_Fetch_OverlayPointer(SO->Overlays, SO->N_Overlays, "Convexity", &junk))) {
07435 SUMA_SL_Err("Failed to find overlay plane 'Convexity'");
07436 SUMA_RETURN(NOPE);
07437 }
07438
07439
07440 eee = getenv("SUMA_ConvColorMap");
07441 if (eee) {
07442 icmap = SUMA_Find_ColorMap ( eee, SUMAg_CF->scm->CMv, SUMAg_CF->scm->N_maps, -2 );
07443 if (icmap < 0) {
07444 SUMA_SL_Err("Colormap specified in\n"
07445 "environment variable SUMA_ConvColorMap\n"
07446 "was not found. Using ngray20.\n");
07447 SUMA_STRING_REPLACE(ConvPlane->cmapname, "ngray20");
07448 } else {
07449 SUMA_STRING_REPLACE(ConvPlane->cmapname, eee);
07450 }
07451 } else {
07452 SUMA_STRING_REPLACE(ConvPlane->cmapname, "ngray20");
07453 }
07454
07455 SUMA_LH("Deciding on brightness factor");
07456
07457 eee = getenv("SUMA_ConvBrightFactor");
07458 if (eee) {
07459 ConvPlane->OptScl->BrightFact = (float)strtod(eee, NULL);
07460 if (ConvPlane->OptScl->BrightFact < 0) {
07461 SUMA_SL_Err("Brightness factor specified in\n"
07462 "environment variable SUMA_ConvColorMap\n"
07463 "is negative. Using default.\n");
07464 ConvPlane->OptScl->BrightFact = SUMA_DIM_CONVEXITY_COLOR_FACTOR;
07465 }
07466 } else {
07467 ConvPlane->OptScl->BrightFact = SUMA_DIM_CONVEXITY_COLOR_FACTOR;
07468 }
07469
07470
07471 ConvPlane->GlobalOpacity = SUMA_CONVEXITY_COLORPLANE_OPACITY;
07472 ConvPlane->Show = YUP;
07473 ConvPlane->isBackGrnd = YUP;
07474
07475 SUMA_LH("Smoothing Cx");
07476
07477 ConvPlane->OptScl->interpmode = SUMA_NO_INTERP;
07478 ConvPlane->OptScl->ApplyClip = YUP;
07479
07480 IntRange[0] = 5; IntRange[1] = 95;
07481 Cx = (float *)SUMA_GetCx(SO->idcode_str, DsetList, 0);
07482 if (!Cx) { SUMA_SL_Err("Failed to find Cx\n"); SUMA_RETURN (NOPE); }
07483 Vsort = SUMA_PercRange (Cx, NULL, SO->N_Node, IntRange, IntRange, NULL);
07484 if (Vsort[0] < 0 && Vsort[SO->N_Node -1] > 0 ) {
07485
07486 if (fabs(IntRange[0]) > IntRange[1]) {
07487 IntRange[1] = -IntRange[0];
07488 } else {
07489 IntRange[0] = -IntRange[1];
07490 }
07491 } else {
07492
07493 }
07494 if (Vsort) SUMA_free(Vsort); Vsort = NULL;
07495
07496 ConvPlane->OptScl->find = 0;
07497 ConvPlane->OptScl->tind = 0;
07498 ConvPlane->OptScl->bind = 0;
07499 ConvPlane->OptScl->IntRange[0] = IntRange[0]; ConvPlane->OptScl->IntRange[1] = IntRange[1];
07500
07501 ConvPlane->ForceIntRange[0] = IntRange[0]; ConvPlane->ForceIntRange[1] = IntRange[1];
07502
07503 SUMA_RETURN(YUP);
07504 }
07505
07506
07507
07508
07509
07510
07511
07512 int SUMA_GetNodeOverInd (SUMA_OVERLAYS *Sover, int node)
07513 {
07514 static char FuncName[]={"SUMA_GetNodeOverInd"};
07515 int Found, i;
07516 SUMA_Boolean LocalHead = NOPE;
07517
07518 SUMA_ENTRY;
07519
07520
07521
07522 Found = -1;
07523 if (Sover->dset_link->dnel->vec_filled > node) {
07524 if (Sover->NodeDef[node] == node) {
07525 SUMA_LH("Good, found it easily");
07526
07527 if (node >= Sover->N_NodeDef) {
07528
07529
07530 SUMA_LH("Can't tell for sure");
07531 } else {
07532 SUMA_RETURN(node);
07533 }
07534 }
07535 }
07536 if (Found < 0) {
07537 SUMA_LH("The hard way");
07538 i=0;
07539 while (Found <0 && i<Sover->N_NodeDef) {
07540 if (Sover->NodeDef[i] == node) Found = i;
07541 ++i;
07542 }
07543 }
07544
07545 SUMA_RETURN(Found);
07546 }
07547
07548
07549
