00083 {
00084     static char hexstring[] = "0123456789ABCDEF";
00085 
00086     unsigned char   ub;
00087     char          * cp = dest;
00088     int             posn, size, ret;
00089 
00090     if ( (bytes <= 0) || (bytes > 4) )
00091     {
00092         *cp = '\0';
00093         return 0;
00094     }
00095 
00096     size = ulong_size( lsrc );
00097 
00098     if ( (size < bytes) && !pad )       /* use size if we avoid padding  */
00099         ret = size;
00100     else
00101         ret = bytes;
00102 
00103     for ( posn = ret-1; posn >= 0; posn-- )
00104     {
00105         /* write one hex pair for this byte */
00106         ub = ( lsrc >> (posn << 3) ) & 0xff;            /* current ubyte */
00107         *cp++ = hexstring[(ub>>4) & 0xf];               /* upper nibble  */
00108         *cp++ = hexstring[ ub     & 0xf];               /* lower nibble  */
00109     }
00110 
00111     *cp = '\0';
00112 
00113     return ret;
00114 }

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 } 

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    /* not new, check to see if color exists already */
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    /* a new map altogether */
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 }

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    /* not new, check to see if map exists already */
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    /* a new map altogether */
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 }

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    /* also try looking for plane by name */
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    /* make sure that overlay plane does not have bias in it */
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          /* If you want to support this feature, you'll have to call SUMA_ADD_COORD_BIAS_VECT
05957          on any surface the plane gets assigned to. That means SO and SO2 below.
05958          Search for macro SUMA_ADD_COORD_BIAS_VECT in SUMA_SwitchState in file SUMA_Engine.c
05959          for the example */
05960          SUMA_RETURN(NOPE);
05961       }
05962    }
05963    /* make sure there's enough room for the new plane */
05964    if (SO->N_Overlays+1 >= SUMA_MAX_OVERLAYS) {
05965       SUMA_SL_Crit("Too many color overlays.");
05966       SUMA_RETURN (NOPE);
05967    }
05968    
05969    /* Now add the plane where it belongs */
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    /* place the Overlay plane and its inode in SO */
05995    SO->Overlays[SO->N_Overlays] = Overlay;
05996    /* Now increment the number of overlays to be in SO */
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    /* Now register plane with surfaces deserving it*/
06005    if (dov) {
06006       SUMA_LH("Registering plane with surfaces deserving it");
06007       /* Now that you have the color overlay plane set, go about all the surfaces, searching for ones related to SO 
06008       and make sure they have this colorplane, otherwise, create a link to it. */   
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) { /* only 1st order kinship allowed */
06013                /* surfaces related and not identical, check on colorplanes */
06014                if (!SUMA_Fetch_OverlayPointer (SO2->Overlays, SO2->N_Overlays, Overlay->Name, &OverInd)) {
06015                   /* color plane not found, link to that of SO */
06016                   SO2->Overlays[SO2->N_Overlays] = (SUMA_OVERLAYS *)SUMA_LinkToPointer((void*)SO->Overlays[SO->N_Overlays-1]);
06017                   /*increment the number of overlay planes */
06018                   ++SO2->N_Overlays;
06019                } else {
06020                   /* colorplane found OK */
06021                }
06022             }
06023          }
06024       }
06025    }
06026    SUMA_RETURN (YUP);
06027 }

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    /* check for obvious insult */
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    /* Check for Col Index*/
06587    iv = SUMA_GetDsetColIndex (dset, SUMA_NODE_INDEX, &N_i);
06588    if (!iv) {
06589       SUMA_LH("No node index column");
06590       /* would the first column work ? */
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          /* check if all values are ints and if they are within 0 and SO->N_Node -1 */
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             /* You can't just change the label and the type of the 0th column to be SUMA_NODE_INDEX because
06617             this column is float, not ints. Duplicate ahead...*/
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       /* Now add Ti to the dataset as a node index column ... */
06629       /* if you change the column label's string ("Node Index (inferred)") 
06630       make sure you change SUMA_isColumn_inferred accordingly */
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       /* all done */
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       /* Nothing to do, return on a positive note */
06645       SUMA_RETURN(YUP);      
06646    } 
06647    
06648    SUMA_SL_Err("why are you here ?");
06649    SUMA_RETURN(NOPE);
06650 }

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    /** scan for section strings, which start with "***" **/
07063    ngood = 0; /* assume none will be found */
07064    
07065    str[0] = '\0' ;  /* initialize string */
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       /**-- skip ahead to next section keyword --**/
07075 
07076       SkipSection: while( ! SUMA_ISTARRED(str) ){ SUMA_GETSTR; SUMA_LH(str);}
07077 
07078       /*- 04 Jun 1999 -*/
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       /**-- COLORS section --**/
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){                          /* loop, looking for 'label = color' */
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             /* don't allow 'none' to be redefined! */
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 ;  /* skip to end of outer while loop */   
07120       } /* end of COLORS */
07121 
07122       /**----------------------**/
07123       /**-- PALETTES section --**/
07124 
07125       if( strcmp(str,"***PALETTES") == 0 ){  /* loop, looking for palettes */
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          /* loop, looking for palettes */
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] != '[' ){                     /* found a palette label */
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] != '[' ){                    /* bad news! */
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             /* decide how big the new palette is to be, and what mode  */
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             /* at this point, now loop to read parameters for new palette */
07181             if (LocalHead) {
07182                fprintf(SUMA_STDERR,"%s: About to read %d panes.\n", FuncName, npane);
07183             }
07184             
07185             /* prepare the colormap */
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                /* find that color */
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             /* add the map to the list */
07229             SAC->CMv = SUMA_Add_ColorMap (CM, SAC->CMv, &(SAC->N_maps));  
07230             if (SAC->CMv) ++ngood;
07231             continue ;  /* to end of outer while */
07232          }
07233       } /* end of PALETTES */
07234       SUMA_GETSTR ; goto SkipSection ;             /* find another section */
07235 
07236    }  /* end of while loop */
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 }

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    /* get list of all Overlay planes */
06408    OverlayPlanelist = SUMA_OverlaysToOrderedList (SO, 0);
06409 
06410    /* need a list to store new names */
06411    list = (DList *)SUMA_malloc(sizeof(DList));
06412    dlist_init(list, NULL); /* you don't want to free the strings */
06413    /* need a list to store the pointers, it is useless when SortByOrder is used, but I leave it in to keep the code simple */
06414    listop = (DList *)SUMA_malloc(sizeof(DList)); 
06415    dlist_init(listop, NULL); /* you don't want to free the data as it is copied from  OverlayPlanelist*/
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       /* Now allocate space for that label */
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          /* list is already sorted, just copy the string and object structure pointers to lists */
06441          dlist_ins_next(list, dlist_tail(list), (void*)store);
06442          /* this line is redundant with SortByOrder but it don't hoyt */
06443          dlist_ins_next(listop, dlist_tail(listop), (void*)OvD);
06444       } else {   /* sort the list by aplhpabetical order */
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 { /* must sort first */
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                   /* reached the end, append */
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) { /* Nothing found */
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       /* destroy list */
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    /* return */
06518    SUMA_RETURN (clist_str);  
06519 }

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    /* Now add SUMA's colormaps */
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 }

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 }

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    /* is the coloring direct ? */
07341    if (strcmp(cp->cmapname, "explicit") == 0) {
07342       
07343       SUMA_LH("Explicit color specification");
07344       /* make sure dataset is of type NODE_RGB */
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       /* go ahead and populate cV */
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       /* indirect mapping */
07390       if (!SUMA_ScaleToMap_Interactive (cp)) {
07391          SUMA_SL_Err("Failed in SUMA_ScaleToMap_Interactive.");
07392          SUMA_RETURN(0); 
07393       }
07394       /* cp->N_NodeDef is taken care of inside SUMA_ScaleToMap_Interactive */
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 }

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    /* clean SS */
00886    SS = SUMA_StringAppend (SS, NULL);
00887    /* copy s pointer and free SS */
00888    s = SS->s;
00889    SUMA_free(SS); 
00890   
00891    SUMA_LH("Left");
00892       
00893    SUMA_RETURN(s);
00894 }

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          /* get the color map */
05374          if (!SUMAg_CF->scm) { /* try creating since it is no longer created at initialization */
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    /* clean SS */
05396    SS = SUMA_StringAppend (SS, NULL);
05397    /* copy s pointer and free SS */
05398    s = SS->s;
05399    SUMA_free(SS); 
05400    
05401    SUMA_RETURN(s);
05402 }

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    /* clean SS */
00766    SS = SUMA_StringAppend (SS, NULL);
00767    /* copy s pointer and free SS */
00768    s = SS->s;
00769    SUMA_free(SS); 
00770       
00771    SUMA_RETURN(s);
00772 }

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    /* S->cM = (float **) SUMA_allocate2D(N_Node, 3, sizeof(float));  */
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; /* That is created in the scaleToMap functions if needed */
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 }

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    /* make a link to dset */
04620    SUMA_LH("Linking to Dset");
04621    Sover->dset_link = (SUMA_DSET *)SUMA_LinkToPointer ((void *)dset);
04622    /* N_Nodes is no longer used, use it for sanity check only */
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    /* copy the name */
04631    Sover->Name = (char *)SUMA_calloc (strlen(Name)+1, sizeof(char));
04632    Sover->Name = strcpy(Sover->Name, Name);
04633    
04634    /* create a label */
04635    sfn = SUMA_StripPath((char *)Name);
04636    Sover->Label = sfn.FileName;
04637    if (sfn.Path) SUMA_free(sfn.Path); /* get rid of path */
04638    
04639    
04640    /* not here anymore */
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    /* Sover->ColMat = (float **) SUMA_allocate2D(Sover->N_Alloc, 3, sizeof(float)); NO MORE 2D ! Mar 17 04*/
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; /* no factor applied */
04664    Sover->LocalOpacity[0] = -1.0; /* flag indicating local facts have not been initialized */
04665    Sover->Show = NOPE;
04666    Sover->PlaneOrder = -1; /* No order is specified */
04667    Sover->isBackGrnd = 0; /* no brightness modulation effects */
04668    Sover->DimFact = 0.3;
04669    Sover->ForceIntRange[0] = 0.0; Sover->ForceIntRange[1] = 0.0; /* force nothing */
04670    
04671    /* new, from Feb 20 */
04672    /* default, choose something */
04673    SUMA_LH("SCM stuff");
04674    if (!SUMAg_CF->scm) {  /* try building it */ 
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 }

00709 {
00710    static char FuncName[]={"SUMA_DestroyAfniColors"};
00711    int i;
00712    
00713    if (!SAC) SUMA_RETURN(NULL);
00714    
00715    /* Now clean the colormap vector */
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    /* Now clean the color vector */
00723    SUMA_free(SAC->Cv);
00724    SAC->N_cols = -1;
00725    
00726    /* Now destroy SAC */
00727    SUMA_free(SAC);
00728    
00729    SUMA_RETURN(NULL);
00730 }

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       /* need to create my own sorted version */
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       /* copy V to Vsort */
04550       SUMA_COPY_VEC (V, Vsort, N_V, double, double);
04551       
04552       /* sort Vsort */
04553       isort = SUMA_z_doubqsort (Vsort  , N_V ); SUMA_free(isort);
04554    } 
04555    
04556    /* choose the index for the lower range */
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 }

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 } 

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 }

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             /* don't care about sign */
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 }

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) {  /* loop accross R,G,B columns */
04445       for (i=0; i < lim; ++i) {
04446          t = CM->M[i][j];           /* store color at i to be flipped */
04447          c = CM->N_Col - i - 1;     /* index of color to replace one at i */
04448          CM->M[i][j] = CM->M[c][j]; /* replace color at i */
04449          CM->M[c][j] = t;           /* put old color of i ar c */
04450       } 
04451    }
04452    
04453    if (CM->frac) { /* got to flip fractions */
04454       for (i=0; i < lim; ++i) {
04455          t = CM->frac[i];           /* store fraction at i to be flipped */
04456          c = CM->N_Col - i - 1;     /* index of fraction to replace one at i */
04457          CM->frac[i] = CM->frac[c]; /* replace fraction at i */
04458          CM->frac[c] = t;           /* put old fraction of i at c */
04459       } 
04460    }
04461    
04462    SUMA_RETURNe;
04463 }

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    /* search all dov for ROIs that use the same plane */
06295    for (i=0; i < N_dov; ++i) {
06296       switch (dov[i].ObjectType) { /* case Object Type */
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             /* found one, do nothing and return */
06307             SUMA_RETURN (YUP);
06308          }
06309       }
06310    }   
06311    
06312    /* looks like no other ROIs use that plane, flush it */
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; /* Flushed */
06321    #else
06322       COLP_N_NODEDEF(SO->Overlays[OverInd]) = 0;
06323    #endif
06324    SUMA_RETURN (YUP);
06325 }

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 }

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 }

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 }

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    /* is this pointer used by others ? */
04739    if (Sover->N_links) {
04740       Sover = (SUMA_OVERLAYS*)SUMA_UnlinkFromPointer((void *)Sover);
04741       SUMA_RETURN (YUP);
04742    }
04743    
04744    /* No more links, go for it */
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    /* if (Sover->ColMat) SUMA_free2D ((char **)Sover->ColMat, Sover->N_Alloc); */
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 }

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    /* initilialize*/
00322    N_maps = -1;
00323    N_cols = -1;
00324 
00325    /* add the none color first */
00326    Cv = SUMA_Add_Color ("none", 
00327                         -1.0, -1.0, -1.0, 1.0, 
00328                         Cv, &N_cols);
00329                         
00330    /* get the rgb, floats of each color defined DEFAULT_NCOLOVR */
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    /* Now create the afni color maps with more than 10 panes (excerpts from afni.c)*/
00343    
00344    /* start with positive panes */
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    /** initialize signed pbar panes **/
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    /* now create AFNI's colormaps */
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             /* find out which color this is */
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       /* add the positive map to the list */
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       /* add the negative map to the list */
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    /* perhaps someday include the continuous color maps from AFNI too. 
00487       (see pbar.c file, search for colorscale) */
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    /* load whatever's lurking in the .afnirc files */
00497    /* passing NULL for dc (the last parameter) because I
00498    am not using the continuous color maps yet */
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    /* Show me the results: */
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 }

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 }

07513 {
07514    static char FuncName[]={"SUMA_GetNodeOverInd"};
07515    int Found, i;
07516    SUMA_Boolean LocalHead = NOPE;
07517 
07518    SUMA_ENTRY;
07519 
07520    /* Now look for the node's location in the color overlay plane.
07521    Nodes that are not colored will be absent ... */
07522    Found = -1;
07523    if (Sover->dset_link->dnel->vec_filled > node) { /* try the straight shot */
07524       if (Sover->NodeDef[node] == node) {
07525          SUMA_LH("Good, found it easily");
07526          /* make sure node is not outside number of defined nodes */
07527          if (node >= Sover->N_NodeDef) {
07528             /* this one's masked but it was left over from the previous pass 
07529             Must go search below to make sure whether it is truly masked or not*/
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 }

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 }

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                /* create the fiducial colors */
03212                k = 0;
03213                Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; ++k;/* Red */
03214                Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; ++k;/* Green */
03215                Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 1.0; ++k;/* Blue */
03216                Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; ++k;/* Yellow */
03217                Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; ++k;/* Red */
03218 
03219                /* generate 20 colors colormap */
03220                CM = SUMA_MakeColorMap (Fiducials, k, 20, YUP, SUMA_StandardMapName(mapcode,&nc));
03221                /* free Fiducials */
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                /* create the fiducial colors */
03238                k = 0;
03239                Fiducials[k][0] = 0.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 1.0; ++k;/* Blue */
03240                Fiducials[k][0] = 0.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; ++k;/* Green */
03241                Fiducials[k][0] = 1.0; Fiducials[k][1] = 1.0; Fiducials[k][2] = 0.0; ++k;/* Yellow */
03242                Fiducials[k][0] = 1.0; Fiducials[k][1] = 0.0; Fiducials[k][2] = 0.0; ++k;/* Red */
03243 
03244                /* generate 20 colors colormap */
03245                CM = SUMA_MakeColorMap (Fiducials, k, 19, NOPE, SUMA_StandardMapName(mapcode,&nc));
03246                /* free Fiducials */
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                /* create the fiducial colors */
03264                k = 0;
03265                Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.4; ++k;/* 0.4 gray */
03266                Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.7; ++k;/* 0.8 gray */
03267 
03268                /* generate 2 colors colormap */
03269                CM = SUMA_MakeColorMap (Fiducials, k, 2, NOPE, SUMA_StandardMapName(mapcode,&nc));
03270                /* free Fiducials */
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                /* create the fiducial colors */
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                /* generate 2 colors colormap */
03293                CM = SUMA_MakeColorMap (Fiducials, k, 2, NOPE, SUMA_StandardMapName(mapcode,&nc));
03294                /* free Fiducials */
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                /* create the fiducial colors */
03311                k = 0;
03312                Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.3; ++k;/* 0.3 gray */
03313                Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.8; ++k;/* 0.8 gray */
03314 
03315                /* generate 20 colors colormap */
03316                CM = SUMA_MakeColorMap (Fiducials, k, 20, NOPE, SUMA_StandardMapName(mapcode,&nc));
03317                /* free Fiducials */
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                /* create the fiducial colors */
03335                k = 0;
03336                Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.3; ++k;/* 0.3 gray */
03337                Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.8; ++k;/* 0.8 gray */
03338 
03339                /* generate 20 colors colormap */
03340                CM = SUMA_MakeColorMap (Fiducials, k, 20, NOPE, SUMA_StandardMapName(mapcode,&nc));
03341                /* free Fiducials */
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                /* create the fiducial colors */
03359                k = 0;
03360                Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 0.0; ++k;/* black  */
03361                Fiducials[k][0] = Fiducials[k][1] = Fiducials[k][2] = 1.0; ++k;/* white */
03362 
03363                /* generate 20 colors colormap */
03364                CM = SUMA_MakeColorMap (Fiducials, k, 20, NOPE, SUMA_StandardMapName(mapcode,&nc));
03365                /* free Fiducials */
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                /* default matlab color map */
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                /* create the fiducial colors */
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                /* generate 20 colors colormap */
03402                CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03403                
03404                /* free Fiducials & Nind*/
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                /* default matlab color map */
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                /* create the fiducial colors */
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                /* generate 64 colors colormap */
03444                CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03445                
03446                /* free Fiducials & Nind*/
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                /* a large colormap for lots of ROI drawing */
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                /* create the fiducial colors */
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                /* generate colormap */
03482                CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03483                
03484                /* free Fiducials & Nind*/
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                /* a large colormap for lots of ROI drawing */
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                /* create the fiducial colors */
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                /* generate colormap */
03522                CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03523                
03524                /* free Fiducials & Nind*/
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                /* a large colormap for lots of ROI drawing */
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                /* create the fiducial colors */
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                /* generate colormap */
03561                CM = SUMA_MakeColorMap_v2 (Fiducials, k, Nind, NOPE, SUMA_StandardMapName(mapcode,&nc));
03562                
03563                /* free Fiducials & Nind*/
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    }

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] == '#') { /* explicitly defined */
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 { /* named */
07283          /* XtAppInitialize (at least on mac osx) forces the application to quit if display cannot be opened
07284          So you must decide ahead of time whether to call it or not! */
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             /* You need to divide by color_exact.red ,green and blue by 257
07294             to bring the numbers in the 0..255 range as listed in the rgb.txt file */
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 }

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       /* if plane exists use it, else create a new one on the mappable surface */
06098       if (!SUMA_Fetch_OverlayPointer (SO->Overlays, SO->N_Overlays, Name, &OverInd)) {
06099          SUMA_LH("pointer not found");
06100          /* overlay plane not found, create a new one on the mappable surface*/
06101          if (!SUMA_isLocalDomainParent(SO)) {
06102             if (sopd->Source == SES_Afni) {
06103                /* unexpected, surfaces coming from AFNI with a map should be a local domain parent */
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);   /* first create a dataset that will go with that colorplane */   
06117          SUMA_free(DsetName_tmp); DsetName_tmp = NULL;
06118          /* insert that element into DaList */
06119          if (!SUMA_InsertDsetPointer(dset, DsetList)) {
06120             SUMA_SL_Err("Failed to insert dset into list");
06121             SUMA_RETURN(NOPE);
06122          }
06123          /* We'll be using NodeDef here so begin by allocating space for the various entries */
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          /* set up some defaults for the overlap plane */
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          /* Add this plane to SO->Overlays */
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"); /* explict color definition in data */
06170       SO->Overlays[OverInd]->FullList = 0; /*!< This type of planes is not usually a full list because it has the nodes defined*/
06171       
06172       /* Now put the colors in the overlay plane */
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; /* set the number of nodes filled IN THE OVERLAY PLANE*/
06178       SO->Overlays[OverInd]->dset_link->dnel->vec_filled = i_max; /* set the number of nodes filled IN THE DSET, For this
06179                                                       type of dsets, the N_NodeDef is the same for both OVERLAY
06180                                                       and DSET*/
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          /* find the columns you need to fill. You can't use SUMA_FillNelCol directly because
06187          columns (vectors) are of different types */
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          /* Now store these colors into the dataset */
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                      /*fprintf(SUMA_STDERR,"Node %d: r%d, g%d, b%d\n", inel[i], r[i], g[i], b[i]);*/
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                      /*fprintf(SUMA_STDERR,"Node %d: r%f, g%f, b%f\n", inel[i], r[i], g[i], b[i]);*/
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       /* Now you want to create the colors of that plane based on the data in dset */
06264       if (!SUMA_ColorizePlane (SO->Overlays[OverInd])) {
06265          SUMA_SLP_Err("Failed to colorize plane.\n");
06266          SUMA_RETURN(NOPE);
06267       }
06268       
06269       /* store overlay plane index here, OverInd will get mango-ed further down */
06270       if (LocalHead) fprintf (SUMA_STDERR, "%s: OverInd = %d. Returning.\n", FuncName, OverInd);
06271       *PlaneInd = OverInd;
06272 
06273    SUMA_RETURN (YUP);
06274 
06275 }

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 }

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 }

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;     /* set default linear map length */
01179    
01180    if (!N_lin) {
01181       SUMA_S_Err("N_lin = 0");
01182       SUMA_RETURN(LSM);
01183    }
01184    
01185    /* allocate for new map */
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    /* copy last value */
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 }

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    /* First pass, do background */
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    /* second pass, do foreground */
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 }

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    /* find out if file exists and how many values it contains */
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    /* dim colors from maximum intensity to preserve surface shape highlights, division by 255 is to scale color values between 1 and 0 */
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    /* values were copied, dump structure */
06964    irgb = SUMA_Free_IRGB(irgb);  
06965 
06966    /* See note before similar line in SUMA_LoadDsetFile */
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    /*update the list widget if open */
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    /* update the color plane frame */
06983    if (OverInd >= 0)        
06984       SUMA_InitializeColPlaneShell(SO, SO->Overlays[OverInd]);
06985 
06986    SUMA_RETURNe;
06987 }

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    /* find out if file exists and how many values it contains */
06775    if (!SUMA_filexists(filename)) {
06776       SUMA_SLP_Err("File not found");
06777       SUMA_RETURNe;
06778    }
06779 
06780    /* take a stab at the format */
06781    form = SUMA_GuessFormatFromExtension(filename);
06782    
06783    /* load the dude */
06784    /* first, set the parent ID of the dset to be loaded,
06785    This ID is only used when generating an ID for those dsets
06786    that have no ID attached, like the 1D ones */
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);  /* reset the parent surface flag */
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    /* Check if the domain order is SO or not .
06806    If not specified, assign it */
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    /* add the dset to the list SUMAg_CF->DsetList*/
06827    if (!SUMA_InsertDsetPointer(dset, SUMAg_CF->DsetList)) {
06828       SUMA_SLP_Err("Failed to add new dset to list");
06829       /* is there not a function to replace a dset yet? */
06830       SUMA_FreeDset(dset); dset = NULL;
06831       SUMA_RETURNe;
06832    }
06833     
06834    /* set up the colormap for this dset */
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    /* The overlay index for that plane is SO->N_Overlays */
06842    OverInd = SO->N_Overlays;
06843    
06844    /* Add this plane to SO->Overlays */
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    /* set the opacity, index column and the range */
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    /* stick a colormap onto that plane ? */
06863       /* don't worry, there's a default one */
06864    
06865    /* colorize the plane */
06866    SUMA_ColorizePlane(NewColPlane);
06867 
06868    /* SUMA_Show_ColorOverlayPlanes(&NewColPlane, 1, 1); */
06869    
06870    /* set the new curColPlane to the newly loaded plane,
06871    you need to do this before you remix the colors in case
06872    you are only showing the curColPlane.
06873    curColPlane is normally set in  SUMA_InitializeColPlaneShell
06874    but when SO->SurfCont->ShowCurOnly = YUP, curColPlane
06875    is used in the RemixRedisplay function.
06876    NOTE: You can't call SUMA_InitializeColPlaneShell
06877    before remixing because colors are reported in Lbl block
06878     June 28 04*/
06879    SO->SurfCont->curColPlane = SO->Overlays[OverInd]; 
06880         
06881    /* remix-redisplay  for surface */
06882    if (!SUMA_RemixRedisplay (SO)) {
06883       SUMA_RETURNe;
06884    }
06885   
06886    SUMA_LH("Refreshing Dset list");            
06887    /*update the list widget if open */
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    /* update the Dset frame */
06896    if (OverInd >= 0)        
06897       SUMA_InitializeColPlaneShell(SO, SO->Overlays[OverInd]);
06898 
06899    SUMA_RETURNe;
06900 }

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    /* check for bad input */
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    /* determine the number of intermediate colors */
00081    if (SkipLast) Ninter = Ncols - (Nfid - 1);
00082    else Ninter = Ncols - Nfid;
00083    
00084    Ngap = Nfid - 1;
00085    
00086    /* you must have an equal number of colours in each gap */ 
00087    if (Ninter % Ngap) {
00088       /* bad, sugeest a better number */
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    /* allocate for M */
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    /* start forming M */
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       /*fprintf (SUMA_STDERR,"%s:  dFid = %f %f %f\n", FuncName, dFid[0], dFid[1] , dFid[2]);*/
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             /*fprintf (SUMA_STDERR,"%s: M[%d][:] = %f %f %f\n", FuncName, im, M[im][0], M[im][1], M[im][2]); */
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    /* package the resutls */
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; /* a linear map */
00149    SM->cname = NULL;
00150    SM->Sgn = 0; /* setup for linear maps with no signing, mapping a la old ScaleToMap*/
00151    SM->SO = NULL; /* created when needed */
00152 
00153    SUMA_RETURN (SM);
00154 }

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    /* check for bad input and calculate the total number of colors*/
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    /* allocate for M */
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    /* start forming M */
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          /*fprintf (SUMA_STDERR,"%s:  dFid = %f %f %f\n", FuncName, dFid[0], dFid[1] , dFid[2]);*/
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                /*fprintf (SUMA_STDERR,"%s: M[%d][:] = %f %f %f\n", FuncName, im, M[im][0], M[im][1], M[im][2]); */
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    /* package the resutls */
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; /* a linear map */
00260    SM->cname = NULL;
00261    SM->Sgn = 0; /* setup for linear maps with no signing, mapping a la old ScaleToMap*/
00262    SM->SO = NULL; /* created when needed */
00263    SUMA_RETURN (SM);
00264 }

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 }