02128 {
02129    static char FuncName[]={"SUMA_Assign_HostName"};
02130    int istart = 0, istop = 0, i = 0;
02131    SUMA_Boolean LocalHead = NOPE;
02132    
02133    SUMA_ENTRY;
02134 
02135    if (istream == -1) {
02136       istart = 0; istop = SUMA_MAX_STREAMS; 
02137    } else {
02138       istart = istream; istop = istream + 1;
02139    }
02140    
02141    for (i = istart; i < istop; ++i) {
02142       if (HostName == NULL)
02143          if (i == SUMA_AFNI_STREAM_INDEX) {
02144             sprintf(cf->HostName_v[i], "localhost"); /*  using localhost will allow the use of Shared Memory.
02145                                                          That is only allowed for SUMA<-->AFNI */
02146          } else {
02147             sprintf(cf->HostName_v[i], "127.0.0.1");  /* force TCP for the commoners */
02148          }  
02149       else {   
02150          if (strlen(HostName) > SUMA_MAX_NAME_LENGTH - 20) {
02151             fprintf(SUMA_STDERR,"Error %s: too long a host name (> %d chars).\n", FuncName, SUMA_MAX_NAME_LENGTH - 20);
02152             SUMA_RETURN (NOPE);
02153          }
02154          sprintf(cf->HostName_v[i],"%s", HostName);
02155       }
02156 
02157       sprintf(cf->NimlStream_v[i],"tcp:%s:%d", 
02158             cf->HostName_v[i], cf->TCP_port[i]);
02159 
02160       if (LocalHead) fprintf(SUMA_STDOUT, "%s: Set HostName %d to %s (stream name: %s)\n", 
02161                      FuncName, i, cf->HostName_v[i], cf->NimlStream_v[i]);
02162    }
02163    
02164    SUMA_RETURN (YUP);
02165 }

01482 {
01483    static char FuncName[]={"SUMA_CanTalkToAfni"};
01484    int i;
01485    SUMA_SurfaceObject *SO;
01486    
01487    SUMA_ENTRY;
01488    
01489    for (i=0; i< N_dov; ++i) {
01490       if (SUMA_isSO(dov[i])) {
01491          SO = (SUMA_SurfaceObject *)(dov[i].OP);
01492          if (SO->LocalDomainParentID != NULL && SO->VolPar != NULL) {
01493             SUMA_RETURN (YUP);
01494          }
01495       } 
01496    }
01497    
01498    SUMA_RETURN (NOPE);
01499 }

02063 {
02064    static char FuncName[]={"SUMA_Create_CommSrtuct"};
02065    SUMA_COMM_STRUCT *cs=NULL;
02066    int i;
02067    
02068    SUMA_ENTRY;
02069    
02070    cs = (SUMA_COMM_STRUCT *)SUMA_malloc(sizeof(SUMA_COMM_STRUCT));
02071    if (!cs) {
02072       SUMA_SL_Crit("Failed to allocate");
02073       SUMA_RETURN(NULL);
02074    }
02075    
02076    cs->talk_suma = 0;
02077    cs->comm_NI_mode = NI_BINARY_MODE;
02078    cs->rps = -1.0;
02079    cs->Send = NOPE;
02080    cs->afni_Send = NOPE;
02081    cs->GoneBad = NOPE;
02082    cs->afni_GoneBad = NOPE;
02083    cs->nelps = -1.0;
02084    cs->TrackID = 0;
02085    cs->istream = -1; /* the index of the stream in SUMAg_CF->ns_v */
02086    cs->afni_istream = -1;
02087    cs->suma_host_name = NULL;
02088    cs->afni_host_name = NULL;
02089    cs->kth = 1;
02090    cs->Feed2Afni = 0;
02091    for (i=0; i<SUMA_N_DSET_TYPES; ++i) cs->ElInd[i] = 0;
02092    SUMA_RETURN(cs);
02093 }

01689 {
01690    static char FuncName[]={"SUMA_DrawnROI_to_NIMLDrawnROI"};
01691    SUMA_NIML_DRAWN_ROI *nimlROI=NULL;
01692    SUMA_ROI_DATUM *ROI_Datum=NULL;
01693    DListElmt *Elm = NULL;
01694    int i = -1;
01695    SUMA_Boolean LocalHead = NOPE;
01696 
01697    SUMA_ENTRY;
01698 
01699    if (!ROI) {
01700       SUMA_SL_Err("Null ROI");
01701       SUMA_RETURN(NULL);
01702    }
01703    
01704    /* allocate for nimlROI */
01705    nimlROI = (SUMA_NIML_DRAWN_ROI *)SUMA_malloc(sizeof(SUMA_NIML_DRAWN_ROI));
01706    
01707    nimlROI->Type = (int)ROI->Type;
01708    nimlROI->idcode_str = ROI->idcode_str;
01709    nimlROI->Parent_idcode_str = ROI->Parent_idcode_str;
01710    nimlROI->Label = ROI->Label;
01711    nimlROI->iLabel = ROI->iLabel;
01712    nimlROI->N_ROI_datum = dlist_size(ROI->ROIstrokelist);
01713    nimlROI->ColPlaneName = ROI->ColPlaneName;
01714    nimlROI->FillColor[0] = ROI->FillColor[0];
01715    nimlROI->FillColor[1] = ROI->FillColor[1];
01716    nimlROI->FillColor[2] = ROI->FillColor[2];
01717    nimlROI->EdgeColor[0] = ROI->EdgeColor[0];
01718    nimlROI->EdgeColor[1] = ROI->EdgeColor[1];
01719    nimlROI->EdgeColor[2] = ROI->EdgeColor[2];
01720    nimlROI->EdgeThickness = ROI->EdgeThickness;
01721    if (!nimlROI->N_ROI_datum) {
01722       nimlROI->ROI_datum = NULL;
01723       SUMA_RETURN(nimlROI);
01724    }
01725    nimlROI->ROI_datum = (SUMA_NIML_ROI_DATUM *)SUMA_malloc(nimlROI->N_ROI_datum*sizeof(SUMA_NIML_ROI_DATUM));
01726 
01727    /* now fill the ROI_datum structures */
01728    Elm = NULL;
01729    i = 0;
01730    do {
01731       if (!Elm) Elm = dlist_head(ROI->ROIstrokelist);
01732       else Elm = Elm->next;
01733       ROI_Datum = (SUMA_ROI_DATUM *)Elm->data;
01734       nimlROI->ROI_datum[i].action = ROI_Datum->action;
01735       nimlROI->ROI_datum[i].Type = ROI_Datum->Type;
01736       nimlROI->ROI_datum[i].N_n = ROI_Datum->N_n;
01737       nimlROI->ROI_datum[i].nPath = ROI_Datum->nPath;
01738       
01739 /*    
01740       nimlROI->ROI_datum[i].N_t = ROI_Datum->N_t;
01741       nimlROI->ROI_datum[i].tPath = ROI_Datum->tPath; */
01742       ++i;
01743    } while (Elm != dlist_tail(ROI->ROIstrokelist));
01744    
01745    SUMA_RETURN(nimlROI);
01746 }

01913 {
01914       if (!Solo) {
01915       ROI *myroi ;
01916       ROI_seg *myseg , *inseg ;
01917       int roi_type ;
01918       NI_element *nel ;
01919       NI_stream ns ;
01920       char *atr ;
01921       int nseg,ii , nnod,jj ;
01922 
01923       /* define struct to read from element */
01924 
01925       roi_type = NI_rowtype_define( "ROI_seg" , "int,int[#1]" ) ;
01926       printf("roi_type code = %d\n",roi_type) ;
01927 
01928       /* open file and read 1 data element */
01929 
01930       ns = NI_stream_open( "file:qroi.dat" , "r" ) ;
01931       if( ns == NULL ){
01932         fprintf(stderr,"Can't open qroi.dat!\n"); exit(1);
01933       }
01934       nel = NI_read_element(ns,1) ;  NI_stream_close(ns) ;
01935       if( nel == NULL ){
01936         fprintf(stderr,"Can't read element from qroi.dat!\n"); exit(1);
01937       }
01938 
01939       /* check input element name and type */
01940 
01941       printf("element name = %s\n",nel->name) ;
01942       printf("  nel->vec_num     = %d\n",nel->vec_num) ;         /* # of vectors */
01943       printf("  nel->vec_type[0] = %d\n",nel->vec_typ[0]) ;    /* type of vec #0 */
01944       if( strcmp(nel->name,"ROI") != 0 ) exit(1) ;
01945 
01946       myroi = malloc(sizeof(ROI)) ;                  /* create output ROI struct */
01947       atr = NI_get_attribute( nel , "ROI_val") ;   /* set ROI val from attribute */
01948       myroi->val = (atr == NULL) ? 0.0 : strtod(atr,NULL) ;
01949       atr = NI_get_attribute( nel , "ROI_name") ; /* set ROI name from attribute */
01950       NI_strncpy(myroi->name,atr,128) ;
01951       myroi->num_seg = nseg = nel->vec_len ;      /* element is array of ROI_seg */
01952       inseg = nel->vec[0] ;                            /* input array of ROI_seg */
01953       myroi->seg = malloc(sizeof(ROI_seg)*nseg); /* make output array of ROI_seg */
01954 
01955       for( ii=0 ; ii < nseg ; ii++ ){        /* copy input array to output array */
01956         myroi->seg[ii].num_nod = nnod = inseg[ii].num_nod ;
01957         if( nnod > 0 ){
01958           myroi->seg[ii].nod = malloc(sizeof(int)*nnod) ;
01959           memcpy( myroi->seg[ii].nod , inseg[ii].nod , sizeof(int)*nnod ) ;
01960         } else {
01961           myroi->seg[ii].nod = NULL ;
01962         }
01963       }
01964 
01965       printf("  val    = %g\n"
01966              "  name   = %s\n"
01967              "  num_seg= %d\n" , myroi->val , myroi->name , myroi->num_seg ) ;
01968       for( ii=0 ; ii < nseg ; ii++ ){
01969         printf("  Segment #%d has %d nodes:",ii,myroi->seg[ii].num_nod) ;
01970         for( jj=0 ; jj < myroi->seg[ii].num_nod ; jj++ )
01971           printf(" %d",myroi->seg[ii].nod[jj]) ;
01972         printf("\n") ;
01973       }
01974 
01975       printf("\nWriting element to stdout\n") ; fflush(stdout) ;
01976       ns = NI_stream_open( "stdout:" , "w" ) ;
01977       NI_write_element( ns , nel , NI_TEXT_MODE | NI_HEADERSHARP_FLAG ) ;
01978       NI_stream_close( ns ) ; NI_free_element(nel) ;
01979    }
01980    /*********Me ROI*********/
01981    {
01982       char *idcode_str, *Parent_idcode_str, *Label, stmp[200]; 
01983       int *nPath0, *nPath1, N_n0, N_n1, i, niml_ROI_Datum_type;
01984       NI_element *nel ;
01985       NI_stream ns ;
01986       SUMA_NIML_DRAWN_ROI *niml_ROI = NULL;
01987       
01988       idcode_str = (char*) malloc(sizeof(char) * 200); sprintf(idcode_str,"Moma- idcode_str");
01989       Parent_idcode_str = (char*) malloc(sizeof(char) * 200); sprintf(Parent_idcode_str,"El Parent");
01990       Label = (char*) malloc(sizeof(char) * 200); sprintf(Label,"Da laba");
01991       N_n0 = 3;
01992       N_n1 = 4;
01993       nPath0 = (int*) calloc(N_n0, sizeof(int));
01994       nPath1 = (int*) calloc(N_n1, sizeof(int));
01995       nPath0[0] = 2; nPath0[1] = 1; nPath0[2] = 10;
01996       nPath1[0] = 9; nPath1[1] = 7; nPath1[2] = 23; nPath1[3] = -3;
01997        
01998       fprintf(stderr,"*********** Defining row type\n");
01999       niml_ROI_Datum_type = NI_rowtype_define("SUMA_NIML_ROI_DATUM", "int,int,int,int[#3]");
02000       
02001       niml_ROI = (SUMA_NIML_DRAWN_ROI *)malloc(sizeof(SUMA_NIML_DRAWN_ROI));
02002       niml_ROI->Type = 4;
02003       niml_ROI->idcode_str = idcode_str;
02004       niml_ROI->Parent_idcode_str = Parent_idcode_str;
02005       niml_ROI->Label = Label;
02006       niml_ROI->iLabel = 20;
02007       niml_ROI->N_ROI_datum = 2;
02008       niml_ROI->ROI_datum = (SUMA_NIML_ROI_DATUM *)malloc(niml_ROI->N_ROI_datum*sizeof(SUMA_NIML_ROI_DATUM));
02009 
02010       /* now fill the ROI_datum structures */
02011       
02012       niml_ROI->ROI_datum[0].N_n = N_n0;
02013       niml_ROI->ROI_datum[1].N_n = N_n1;
02014       if (1) {
02015          fprintf(stderr,"*********** Filling ROI_datum structures\n");
02016          niml_ROI->ROI_datum[0].nPath = nPath0;
02017          niml_ROI->ROI_datum[1].nPath = nPath1;
02018       }else {
02019          fprintf(stderr,"*********** Skipping ROI_datum structure fill.\n");
02020       }
02021 
02022       fprintf(stderr,"*********** Creating new data element, a column of %d elements \n", niml_ROI->N_ROI_datum);
02023       nel = NI_new_data_element("A_drawn_ROI",  niml_ROI->N_ROI_datum);
02024       
02025       fprintf(stderr,"*********** Adding column\n");
02026       NI_add_column( nel , niml_ROI_Datum_type, niml_ROI->ROI_datum );
02027       
02028       fprintf(stderr,"*********** Setting attributes element\n");
02029       NI_set_attribute (nel, "Object_ID", niml_ROI->idcode_str);
02030       NI_set_attribute (nel, "Parent_ID", niml_ROI->Parent_idcode_str);
02031       NI_set_attribute (nel, "Label", niml_ROI->Label);
02032       sprintf(stmp,"%d", niml_ROI->iLabel);
02033       NI_set_attribute (nel, "iLabel", stmp);
02034       sprintf(stmp,"%d", niml_ROI->Type);
02035       NI_set_attribute (nel, "Type", stmp);
02036    
02037       /* Now write the element */
02038       ns = NI_stream_open( "fd:1" , "w" ) ;
02039       if (NI_write_element( ns , nel , NI_TEXT_MODE | NI_HEADERSHARP_FLAG ) < 0) {
02040          fprintf(stderr,"*********** Badness, failed to write nel\n");
02041       } 
02042       NI_stream_close( ns ) ; 
02043 
02044       /* free nel */
02045       NI_free_element(nel) ; nel = NULL;
02046       
02047       /* free the rest */
02048       free(nPath0);
02049       free(nPath1);
02050       free(idcode_str);
02051       free(Parent_idcode_str);
02052       free(Label);
02053    }
02054 
02055 }

02096 {
02097    static char FuncName[]={"SUMA_Free_CommSrtuct"};
02098    
02099    SUMA_ENTRY;
02100    
02101    if (cs) {
02102       if (cs->suma_host_name) SUMA_free(cs->suma_host_name); cs->suma_host_name = NULL;
02103       if (cs->afni_host_name) SUMA_free(cs->afni_host_name); cs->afni_host_name = NULL;
02104       SUMA_free(cs);   
02105    }
02106    
02107    SUMA_RETURN(NULL);
02108 }

01879 {
01880    static char FuncName[]={"SUMA_Free_NIMLDrawROI"};
01881    SUMA_Boolean LocalHead = NOPE;
01882    
01883    SUMA_ENTRY;
01884 
01885    if (!nimlROI) SUMA_RETURN(NULL);
01886    
01887    if (nimlROI->ROI_datum) SUMA_free(nimlROI->ROI_datum); /* DO NOT FREE MEMORY POINTED to by fields inside nimlROI->ROI_datum */
01888    SUMA_free(nimlROI);
01889    
01890    SUMA_RETURN(NULL);
01891 }

01421 {
01422    static char FuncName[]={"SUMA_makeNI_CrossHair"};
01423    NI_element *nel;
01424    float *XYZmap;
01425    int I_C = -1;
01426    SUMA_SurfaceObject *SO;
01427    
01428    SUMA_ENTRY;
01429 
01430    if (sv == NULL) {
01431       fprintf(SUMA_STDERR,"Error %s: Null sv.\n", FuncName);
01432       SUMA_RETURN (NULL);
01433    }
01434    if (sv->Ch == NULL) {
01435       fprintf(SUMA_STDERR,"Error %s: NULL Ch.\n", FuncName);
01436       SUMA_RETURN (NULL);
01437    }
01438 
01439    SO = (SUMA_SurfaceObject *)(SUMAg_DOv[sv->Focus_SO_ID].OP);
01440    I_C = SO->SelectedNode;
01441    XYZmap = SUMA_XYZ_XYZmap (sv->Ch->c, SO, SUMAg_DOv, SUMAg_N_DOv, &I_C);
01442    
01443    if (XYZmap == NULL){
01444       fprintf(SUMA_STDERR,"%s: Linkage is not posible, using current XYZ\n", FuncName);
01445       XYZmap = (float *)SUMA_calloc (3, sizeof(float));
01446       if (XYZmap == NULL) {
01447          fprintf (SUMA_STDERR, "Error %s: Give me a break !\n", FuncName);
01448          SUMA_RETURN (NULL); 
01449       }
01450       XYZmap[0] = sv->Ch->c[0];
01451       XYZmap[1] = sv->Ch->c[1];
01452       XYZmap[2] = sv->Ch->c[2];
01453    }
01454    
01455    /* make a new data element */
01456    nel = NI_new_data_element( "SUMA_crosshair_xyz" , 3) ;
01457    
01458    if (!nel) {
01459       fprintf(SUMA_STDERR,"Error %s: Failed to allocate for nel\n", FuncName);
01460       SUMA_RETURN (NULL);
01461    }
01462    
01463    NI_add_column( nel , NI_FLOAT , XYZmap );
01464    
01465    if (XYZmap) SUMA_free(XYZmap);
01466 
01467    SUMA_RETURN (nel);
01468 }

01343 {
01344    static char FuncName[]={"SUMA_makeNI_SurfIJK"};
01345    NI_element *nel;
01346    int  ii,  ip, NP;
01347    int *I, *J, *K;
01348    
01349    SUMA_ENTRY;
01350 
01351    
01352    if (SO == NULL) {
01353       fprintf(SUMA_STDERR,"Error %s: Null SO.\n", FuncName);
01354       SUMA_RETURN (NULL);
01355    }
01356    if (SO->N_FaceSet <= 0) {
01357       fprintf(SUMA_STDERR,"Error %s: No FaceSets in SO.\n", FuncName);
01358       SUMA_RETURN (NULL);
01359    }
01360    
01361    NP = SO->FaceSetDim;
01362    /* make a new data element, to be filled by columns */
01363    nel = NI_new_data_element( "SUMA_ijk" , SO->N_FaceSet) ;
01364    
01365    /* make the columns to be put in the element */
01366    I = (int *) SUMA_malloc( sizeof(int) * SO->N_FaceSet ) ;
01367    J = (int *) SUMA_malloc( sizeof(int) * SO->N_FaceSet ) ;
01368    K = (int *) SUMA_malloc( sizeof(int) * SO->N_FaceSet ) ;
01369 
01370    if (!nel || !I || !J || !K ) {
01371       fprintf(SUMA_STDERR,"Error %s: Failed to allocate for nel, I, J or K.\n", FuncName);
01372       SUMA_RETURN (NULL);
01373    }
01374    
01375 
01376    /* load the columns from the struct array */
01377 
01378    for( ii=0 ; ii < SO->N_FaceSet ; ii++ ){
01379       ip = NP * ii;
01380       I[ii] = SO->FaceSetList[ip];
01381       J[ii] = SO->FaceSetList[ip+1];
01382       K[ii] = SO->FaceSetList[ip+2];
01383    }
01384 
01385    /* put columns into element */
01386 
01387    NI_add_column( nel , NI_INT   , I ) ; SUMA_free(I) ;
01388    NI_add_column( nel , NI_INT   , J ) ; SUMA_free(J) ;
01389    NI_add_column( nel , NI_INT   , K ) ; SUMA_free(K) ;
01390 
01391    NI_set_attribute (nel, "volume_idcode", SO->VolPar->vol_idcode_str);
01392    NI_set_attribute (nel, "surface_idcode", SO->idcode_str);
01393    NI_set_attribute (nel, "surface_label", SO->Label);
01394    NI_set_attribute (nel, "local_domain_parent_ID", SO->LocalDomainParentID);
01395    NI_set_attribute (nel, "local_domain_parent", SO->LocalDomainParent);
01396 
01397    SUMA_RETURN (nel);
01398 }

01268 {
01269    static char FuncName[]={"SUMA_makeNI_SurfINORM"};
01270    NI_element *nel=NULL;
01271    int *ic=NULL, ii, ND, id;
01272    float *xc=NULL, *yc=NULL, *zc=NULL;
01273    
01274    SUMA_ENTRY;
01275 
01276    
01277    if (SO == NULL) {
01278       fprintf(SUMA_STDERR,"Error %s: Null SO.\n", FuncName);
01279       SUMA_RETURN (NULL);
01280    }
01281    if (SO->N_Node <= 0) {
01282       fprintf(SUMA_STDERR,"Error %s: No nodes in SO.\n", FuncName);
01283       SUMA_RETURN (NULL);
01284    }
01285    if (!SO->NodeNormList) {
01286       fprintf(SUMA_STDERR,"Error %s: No normals in SO.\n", FuncName);
01287       SUMA_RETURN (NULL);
01288    }
01289    
01290    /* make a new data element, to be filled by columns */
01291    nel = NI_new_data_element( "SUMA_node_normals" , SO->N_Node) ;
01292    
01293    /* make the columns to be put in the element */
01294    #ifdef DOINDEX   
01295    ic = (int *)   SUMA_malloc( sizeof(int)   * SO->N_Node ) ;
01296    #endif
01297    xc = (float *) SUMA_malloc( sizeof(float) * SO->N_Node ) ;
01298    yc = (float *) SUMA_malloc( sizeof(float) * SO->N_Node ) ;
01299    zc = (float *) SUMA_malloc( sizeof(float) * SO->N_Node ) ;
01300 
01301    if (!nel || !xc || !yc || !zc) {
01302       fprintf(SUMA_STDERR,"Error %s: Failed to allocate for nel, ic, xc, yc or zc.\n", FuncName);
01303       SUMA_RETURN (NULL);
01304    }
01305    
01306 
01307    /* load the columns from the struct array */
01308    ND = SO->NodeDim;
01309    for( ii=0 ; ii < SO->N_Node ; ii++ ){
01310    #ifdef DOINDEX
01311       ic[ii] = ii;
01312    #endif
01313       id = ND * ii;
01314       xc[ii] = SO->NodeNormList[id];
01315       yc[ii] = SO->NodeNormList[id+1];
01316       zc[ii] = SO->NodeNormList[id+2];
01317    }
01318 
01319    /* put columns into element */
01320 
01321    #ifdef DOINDEX
01322       NI_add_column( nel , NI_INT   , ic ) ; SUMA_free(ic) ; 
01323    #endif
01324    NI_add_column( nel , NI_FLOAT , xc ) ; SUMA_free(xc) ;
01325    NI_add_column( nel , NI_FLOAT , yc ) ; SUMA_free(yc) ;
01326    NI_add_column( nel , NI_FLOAT , zc ) ; SUMA_free(zc) ;
01327 
01328    NI_set_attribute (nel, "volume_idcode", SO->VolPar->vol_idcode_str);
01329    NI_set_attribute (nel, "surface_idcode", SO->idcode_str);
01330    NI_set_attribute (nel, "surface_label", SO->Label);
01331    NI_set_attribute (nel, "local_domain_parent_ID", SO->LocalDomainParentID);
01332    NI_set_attribute (nel, "local_domain_parent", SO->LocalDomainParent);
01333    SUMA_RETURN (nel);
01334 }

01202 {
01203    static char FuncName[]={"SUMA_makeNI_SurfIXYZ"};
01204    NI_element *nel;
01205    int *ic, ii, ND, id;
01206    float *xc, *yc, *zc;
01207     
01208    SUMA_ENTRY;
01209 
01210    
01211    if (SO == NULL) {
01212       fprintf(SUMA_STDERR,"Error %s: Null SO.\n", FuncName);
01213       SUMA_RETURN (NULL);
01214    }
01215    if (SO->N_Node <= 0) {
01216       fprintf(SUMA_STDERR,"Error %s: No nodes in SO.\n", FuncName);
01217       SUMA_RETURN (NULL);
01218    }
01219    
01220    /* make a new data element, to be filled by columns */
01221    nel = NI_new_data_element( "SUMA_ixyz" , SO->N_Node) ;
01222    
01223    /* make the columns to be put in the element */
01224    ic = (int *)   SUMA_malloc( sizeof(int)   * SO->N_Node ) ;
01225    xc = (float *) SUMA_malloc( sizeof(float) * SO->N_Node ) ;
01226    yc = (float *) SUMA_malloc( sizeof(float) * SO->N_Node ) ;
01227    zc = (float *) SUMA_malloc( sizeof(float) * SO->N_Node ) ;
01228 
01229    if (!nel || !ic || !xc || !yc || !zc) {
01230       fprintf(SUMA_STDERR,"Error %s: Failed to allocate for nel, ic, xc, yc or zc.\n", FuncName);
01231       SUMA_RETURN (NULL);
01232    }
01233    
01234 
01235    /* load the columns from the struct array */
01236    ND = SO->NodeDim;
01237    for( ii=0 ; ii < SO->N_Node ; ii++ ){
01238       ic[ii] = ii;
01239       id = ND * ii;
01240       xc[ii] = SO->NodeList[id];
01241       yc[ii] = SO->NodeList[id+1];
01242       zc[ii] = SO->NodeList[id+2];
01243    }
01244 
01245    /* put columns into element */
01246 
01247    NI_add_column( nel , NI_INT   , ic ) ; SUMA_free(ic) ;
01248    NI_add_column( nel , NI_FLOAT , xc ) ; SUMA_free(xc) ;
01249    NI_add_column( nel , NI_FLOAT , yc ) ; SUMA_free(yc) ;
01250    NI_add_column( nel , NI_FLOAT , zc ) ; SUMA_free(zc) ;
01251 
01252    if (SO->VolPar) NI_set_attribute (nel, "volume_idcode", SO->VolPar->vol_idcode_str);
01253    NI_set_attribute (nel, "surface_idcode", SO->idcode_str);
01254    NI_set_attribute (nel, "surface_label", SO->Label);
01255    NI_set_attribute (nel, "local_domain_parent_ID", SO->LocalDomainParentID);
01256    NI_set_attribute (nel, "local_domain_parent", SO->LocalDomainParent);
01257    SUMA_RETURN (nel);
01258 }

02299 {
02300    static char FuncName[]={"SUMA_Mesh_IJK2Mesh_IJK_nel"};
02301    static int i_in=0;
02302    char buf[500];
02303    NI_element *nel=NULL;
02304    SUMA_Boolean LocalHead = NOPE;
02305    
02306    SUMA_ENTRY;
02307    
02308    
02309    if (dtype != SUMA_NEW_MESH_IJK && dtype != SUMA_MESH_IJK) {
02310       SUMA_SL_Err("Bad dtype for this function!");
02311       SUMA_RETURN(NULL);
02312    }
02313    
02314    if (cleanup) {
02315       SUMA_LH("Cleanup..."); 
02316       SUMA_RETURN(NULL);
02317    }
02318    
02319    if (SO->FaceSetDim != 3) { /* only deals with XYZ for the moment */
02320       SUMA_SL_Err("FaceSetDim must be 3!");
02321       SUMA_RETURN(nel);
02322    }
02323    
02324    if (!i_in) {
02325       /* Initialization block. Nothing to do , really */
02326    }
02327    
02328    
02329    /* Now create that data element and write it out */
02330    SUMA_allow_nel_use(1);
02331    nel = SUMA_NewNel (  dtype, /* one of SUMA_DSET_TYPE */
02332                         SO->idcode_str, /* idcode of Domain Parent */
02333                         NULL, /* idcode of geometry parent, not useful here*/
02334                         3*SO->N_FaceSet,
02335                         NULL,
02336                         SO->facesetlist_idcode_str);
02337    if (!nel) {
02338       fprintf (stderr,"Error  %s:\nFailed in SUMA_NewNel", FuncName);
02339       SUMA_RETURN(NULL);
02340    }
02341    
02342    sprintf(buf, "%d", SO->FaceSetDim);
02343    NI_set_attribute (nel, "Mesh_Dim", buf);
02344    
02345    /* set the label */
02346    if (SO->Label) {
02347       sprintf(buf, "FaceSetList for surface %s", SO->Label);
02348       NI_set_attribute (nel, "Object_Label", buf);
02349    } else {
02350       NI_set_attribute (nel, "Object_Label", SUMA_EMPTY_ATTR);
02351    } 
02352      
02353    #if 0 /* no longer needed */
02354       if (!SO->idcode_str) { SUMA_SL_Err("Surface has a NULL idcode_str, BAD.\n"); SUMA_RETURN(NULL);} 
02355       NI_set_attribute (nel, "surface_idcode", SO->idcode_str);   
02356 
02357       if (!SO->Group) { SUMA_SL_Err("Surface has a NULL Group, BAD.\n"); SUMA_RETURN(NULL);} 
02358       NI_set_attribute(nel, "Group", SO->Group);
02359       if (!SO->Label) { NI_set_attribute(nel, "Label", "Def_MeshIJK2MeshIJK_nel"); }
02360       else NI_set_attribute(nel, "Label", SO->Label);
02361       if (!SO->State) { SUMA_SL_Err("Surface has a NULL state, BAD.\n"); SUMA_RETURN(NULL);} 
02362       NI_set_attribute(nel, "State", SO->State);
02363       sprintf(buf, "%d", SO->N_Node);
02364       NI_set_attribute(nel, "N_Node", buf);
02365       NI_set_attribute(nel, "EmbedDim", "3");
02366       NI_set_attribute(nel, "AnatCorrect", "1");
02367    #endif
02368    
02369    #if 0 /* the old way, no need for embellishments */
02370    /* Add the coordinate column */
02371    if (!SUMA_AddNelCol (nel, /* the famed nel */ 
02372                         "IJK indices", 
02373                         SUMA_NODE_INT, /* the column's type (description),
02374                                             one of SUMA_COL_TYPE */
02375                         (void *)val, /* the coordinates */
02376                         NULL  /* that's an optional structure containing 
02377                                  attributes of the added column. 
02378                                  Not used at the moment */
02379                         ,1
02380                         )) {
02381       fprintf (stderr,"Error  %s:\nFailed in SUMA_AddNelCol", FuncName);
02382       SUMA_RETURN(NULL);                    
02383    }
02384    #else
02385       NI_add_column_stride ( nel, NI_INT, val, 1 );
02386    #endif
02387 
02388    ++i_in; 
02389          
02390    /* return the element */
02391    SUMA_RETURN(nel); 
02392 
02393 }    

02241 {
02242    static char FuncName[]={"SUMA_Mesh_IJK_nel2Mesh_IJK"};
02243    SUMA_DSET_TYPE dtype;
02244    char *tmp=NULL;
02245    SUMA_Boolean LocalHead = NOPE;
02246    
02247    SUMA_ENTRY;
02248    
02249    dtype = SUMA_Dset_Type(nel->name);
02250    if (dtype != SUMA_NEW_MESH_IJK && dtype != SUMA_MESH_IJK) {
02251       SUMA_SL_Err("Bad dtype for this function!");
02252       SUMA_RETURN(NOPE);
02253    }
02254    
02255    tmp = NI_get_attribute(nel, "Parent_ID");
02256    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) {
02257       if (strcmp(SO->idcode_str, tmp)) {
02258          SUMA_SL_Err("idcode mismatch."); SUMA_RETURN(NOPE);
02259       }
02260    }
02261    tmp = NI_get_attribute(nel, "Object_ID");
02262    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->facesetlist_idcode_str = SUMA_copy_string(tmp);
02263    
02264    tmp = NI_get_attribute(nel, "Mesh_Dim");
02265    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->FaceSetDim = atoi(tmp);
02266    else SO->FaceSetDim = 0;
02267    
02268    if (SO->FaceSetDim != 3) {
02269       SUMA_SL_Err("FaceSetDim must be 3!"); SUMA_RETURN(NOPE);
02270    }
02271    
02272    if (SO->N_FaceSet) {
02273       if (SO->N_FaceSet == nel->vec_len/SO->FaceSetDim ) {
02274          if (!SO->FaceSetList) {
02275             SUMA_SL_Err("Bad init variables. SO->N_FaceSet == nel->vec_len/SO->FaceSetDim && !SO->FaceSetList"); SUMA_RETURN(NOPE);
02276          }
02277       } else {
02278          if (SO->FaceSetList) SUMA_free(SO->FaceSetList); SO->FaceSetList = NULL; 
02279       }
02280    } else {
02281       if (SO->FaceSetList) { SUMA_SL_Err("SO->FaceSetList should be null here!"); SUMA_RETURN(NOPE); }
02282    }
02283    SO->N_FaceSet = nel->vec_len/SO->FaceSetDim;
02284    if (!SO->FaceSetList) SO->FaceSetList = (int *)SUMA_malloc(nel->vec_len * sizeof(int));
02285    if (!SO->FaceSetList) {
02286       SUMA_SL_Crit("Failed to allocate for FaceSetList"); SUMA_RETURN(NOPE); 
02287    }
02288    memcpy((void*)SO->FaceSetList, nel->vec[0], nel->vec_len*sizeof(int));
02289    
02290    SUMA_RETURN(YUP);
02291 }

01401 {
01402    static char FuncName[]={"SUMA_nel_stdout"};
01403    NI_stream nstdout;
01404 
01405    SUMA_ENTRY;
01406 
01407    nstdout = NI_stream_open( "fd:1","w");
01408    if( nstdout == NULL ){ 
01409       fprintf(SUMA_STDERR,"%s: Can't open fd:1\n", FuncName); 
01410       SUMA_RETURN(NOPE); 
01411    }
01412    fprintf (stdout, "\n----------------------------nel stdout begin-------------------\n");
01413    NI_write_element( nstdout , nel , NI_TEXT_MODE ) ;
01414    fprintf (stdout, "----------------------------nel stdout end  -------------------\n");
01415    NI_stream_close(nstdout);
01416 
01417    SUMA_RETURN(YUP);
01418 }

00287 {
00288    static char FuncName[]={"SUMA_niml_call"};
00289    int nn, Wait_tot;
00290    SUMA_Boolean LocalHead = NOPE;
00291    
00292    SUMA_ENTRY;
00293    
00294    if (si < 0 || si >= SUMA_MAX_STREAMS) {
00295       SUMA_SL_Err("Bad value for stream index.");
00296       SUMA_RETURN(NOPE);
00297    }
00298    
00299      /* find out if the stream has been established already */
00300       if (cf->ns_v[si]) { /* stream is open, nothing to do */
00301          cf->ns_flags_v[si] = SUMA_FLAG_CONNECTED;
00302          if (LocalHead) fprintf(SUMA_STDOUT,"%s: Stream existed, reusing.\n", FuncName);
00303          fprintf(SUMA_STDOUT,"%s: Connected.\n", FuncName); fflush(SUMA_STDOUT);
00304       }else {   /* must open stream */              
00305          /* contact afni */
00306             fprintf(SUMA_STDOUT,"%s: Contacting ...\n", FuncName); fflush(SUMA_STDOUT);
00307             cf->ns_v[si] =  NI_stream_open( cf->NimlStream_v[si] , "w" ) ;
00308             if (!cf->ns_v[si]) {
00309                cf->ns_flags_v[si] = 0;
00310                cf->TrackingId_v[si] = 0;
00311 
00312                if (fromSUMA) { SUMA_SLP_Err("NI_stream_open failed (1p)."); }
00313                else { SUMA_SL_Err("NI_stream_open failed (1)."); }
00314                SUMA_BEEP;
00315                cf->Connected_v[si] = !cf->Connected_v[si];
00316                SUMA_RETURN(NOPE) ;
00317             }
00318             if (!strcmp(cf->HostName_v[si],"localhost")) { /* only try shared memory when 
00319                                                                   AfniHostName is localhost */
00320                fprintf (SUMA_STDERR, "%s: Trying shared memory...\n", FuncName);
00321                if( strstr( cf->NimlStream_v[si] , "tcp:localhost:" ) != NULL ) {
00322                   if (!NI_stream_reopen( cf->ns_v[si] , "shm:WeLikeElvis:1M" )) {
00323                      fprintf (SUMA_STDERR, "Warning %s: Shared memory communcation failed.\n", FuncName);
00324                   }
00325                }
00326             }
00327             /*   cf->ns_v[si] = NI_stream_open( "tcp:128.231.212.194:53211" , "w" ) ;*/
00328 
00329             if( cf->ns_v[si] == NULL ){
00330                if (fromSUMA) { SUMA_SLP_Err("NI_stream_open failed (2p)");} 
00331                else { SUMA_SL_Err("NI_stream_open failed (2)");}
00332                SUMA_BEEP; 
00333                cf->Connected_v[si] = !cf->Connected_v[si];
00334                cf->ns_flags_v[si] = 0;
00335                cf->TrackingId_v[si] = 0;
00336 
00337                SUMA_RETURN(NOPE) ;
00338             }
00339 
00340          Wait_tot = 0;
00341          while(Wait_tot < SUMA_WriteCheckWaitMax){
00342             nn = NI_stream_writecheck( cf->ns_v[si] , SUMA_WriteCheckWait) ;
00343             if( nn == 1 ){ 
00344                fprintf(stderr,"\n") ; 
00345                cf->ns_flags_v[si] = SUMA_FLAG_CONNECTED;
00346                SUMA_RETURN(YUP) ; 
00347             }
00348             if( nn <  0 ){ 
00349                fprintf(stderr,"BAD\n"); 
00350                cf->Connected_v[si] = !cf->Connected_v[si];
00351                cf->ns_v[si] = NULL;
00352                cf->ns_flags_v[si] = 0;
00353                cf->TrackingId_v[si] = 0;
00354                SUMA_RETURN(NOPE);
00355             }
00356             Wait_tot += SUMA_WriteCheckWait;
00357             fprintf(SUMA_STDERR,".") ;
00358          }
00359 
00360          /* make sure you did not exit because of time out */
00361          if (nn!=1) {
00362             cf->Connected_v[si] = !cf->Connected_v[si];
00363             cf->ns_v[si] = NULL;
00364             cf->ns_flags_v[si] = 0; 
00365             cf->TrackingId_v[si] = 0;
00366             fprintf(SUMA_STDERR,"Error %s: WriteCheck timed out (> %d ms).\n", FuncName, SUMA_WriteCheckWaitMax);
00367             SUMA_RETURN(NOPE);
00368          }
00369       } 
00370 
00371       /* Stream is open */
00372    SUMA_RETURN(YUP);
00373 }

00233 {
00234    static char FuncName[]={"SUMA_niml_hangup"};
00235    int i;
00236    SUMA_Boolean LocalHead = NOPE;
00237    
00238    SUMA_ENTRY;
00239    
00240    if (!nel_stream_name) {
00241       if (!fromSUMA) { SUMA_SL_Err("NULL stream name"); }
00242       else { SUMA_SLP_Err("NULL stream name"); }
00243       SUMA_RETURN(NOPE);
00244    }
00245    
00246    
00247    i = SUMA_which_stream_index (cf, nel_stream_name);
00248    
00249    
00250    if (i < 0) {
00251       if (!fromSUMA) { SUMA_SL_Err("Stream not found"); }
00252       else {  SUMA_SLP_Err("Stream not found"); }
00253       SUMA_RETURN(NOPE); 
00254    } else {
00255       SUMA_LH("Stream found.");
00256       fprintf (SUMA_STDERR,"%s: stream index %d\n", FuncName, i);
00257       if (killit) {
00258          SUMA_LH("Killing stream");
00259          NI_stream_kill(cf->ns_v[i]);
00260       }else {
00261         SUMA_LH("Just closing stream"); 
00262          NI_stream_close(cf->ns_v[i]);
00263       }
00264       cf->ns_v[i] = NULL;
00265       cf->Connected_v[i] = NOPE; 
00266       cf->ns_flags_v[i] = 0;
00267       cf->TrackingId_v[i] = 0;
00268    }
00269    
00270    SUMA_RETURN(YUP);
00271 }

00028 {
00029    static char FuncName[]={"SUMA_niml_workproc"};
00030    int cc , nn, ngood = 0, id;
00031    void *nini ;
00032    char tmpcom[100], *nel_track;
00033    SUMA_SurfaceViewer *sv;
00034    NI_element *nel ;
00035    DList *list = NULL;
00036    SUMA_EngineData *ED = NULL;
00037    SUMA_Boolean LocalHead = NOPE;
00038    
00039    if (SUMA_NIML_WORKPROC_IO_NOTIFY) {SUMA_ENTRY;}
00040 
00041    if (!SUMAg_CF->niml_work_on) SUMAg_CF->niml_work_on = YUP;
00042    
00043    sv = (SUMA_SurfaceViewer *)thereiselvis;
00044    SUMA_LH("In");
00045    
00046    for (cc=0; cc<SUMA_MAX_STREAMS; ++cc) {
00047      if (cc == SUMA_AFNI_STREAM_INDEX2) continue; /*     this stream is listened to by AFNI and is used by non-suma 
00048                                                          SUMA programs to communicate with AFNI directly. SUMA programs are not 
00049                                                          to receive elements back on this stream (unlike suma with SUMA_AFNI_STREAM_INDEX)
00050                                                          because communications for now are one way only. */
00051      #if 0 
00052      /* *** Pre Dec. 18 03, only SUMA talked to AFNI */ 
00053         /* check if stream is open */
00054 
00055         if( SUMAg_CF->ns == NULL ){
00056           fprintf(SUMA_STDERR,"Error SUMA_niml_workproc: Stream is not open. \n");
00057           if (SUMA_NIML_WORKPROC_IO_NOTIFY) {
00058             SUMA_RETURN(True); /* Don't call me with that lousy stream again */
00059           }
00060             else return (True); /* to reduce the massive amounts of tracing messages */
00061         }
00062       #else
00063       /* *** post Dec. 18 03, making SUMA listen to people's needs */
00064       /* open streams that aren't open */
00065 
00066       
00067       if (cc != SUMA_AFNI_STREAM_INDEX && cc != SUMA_AFNI_STREAM_INDEX2) { /* Leave AFNI's stream alone, SUMA initiates the connection here, 
00068                                                                               SUMA_AFNI_STREAM_INDEX2 is not needed here because of earlier
00069                                                                               condition, but it is left here as a reminder.*/
00070          
00071          if (LocalHead) fprintf (SUMA_STDERR, "%s: Checking on stream %d, %s\n", FuncName, cc,  SUMAg_CF->NimlStream_v[cc]);
00072          if( SUMAg_CF->ns_v[cc] == NULL && (SUMAg_CF->ns_flags_v[cc] & SUMA_FLAG_SKIP)==0 ){
00073             if (LocalHead) fprintf (SUMA_STDERR, "%s: \tNot Skipped.\n", FuncName);
00074             SUMAg_CF->ns_v[cc] = NI_stream_open( SUMAg_CF->NimlStream_v[cc] , "r" ) ;
00075             if( SUMAg_CF->ns_v[cc] == NULL ){
00076                fprintf (SUMA_STDERR, "%s: Stream %d, %s open returned NULL\n", FuncName, cc,  SUMAg_CF->NimlStream_v[cc]); 
00077                SUMAg_CF->ns_flags_v[cc] = SUMA_FLAG_SKIP ; continue;
00078             }
00079             if (LocalHead) fprintf (SUMA_STDERR, "%s: Stream %d, %s open returned NOT null\n", FuncName, cc,  SUMAg_CF->NimlStream_v[cc]);
00080             SUMAg_CF->ns_flags_v[cc]  = SUMA_FLAG_WAITING ;
00081          }else {
00082             if (SUMAg_CF->ns_v[cc] == NULL) { 
00083                SUMA_LH("\tSkipped");
00084                continue;
00085             }
00086          }
00087 
00088          ngood ++;
00089       } else {
00090          if( SUMAg_CF->ns_v[SUMA_AFNI_STREAM_INDEX] ) {
00091             ngood ++;
00092          } else { /* do nothing for that stream */
00093             continue;
00094          }
00095       }
00096       #endif
00097      
00098      /* check if stream has gone bad */
00099      nn = NI_stream_goodcheck( SUMAg_CF->ns_v[cc] , 1 ) ;
00100 
00101      if( nn < 0 ){                          /* is bad */
00102        NI_stream_close( SUMAg_CF->ns_v[cc] ) ;
00103        SUMAg_CF->ns_v[cc] = NULL ; /* this will get checked next time */
00104        fprintf(SUMA_STDERR,"Error SUMA_niml_workproc: Stream %d gone bad. Stream closed. \n", cc);
00105        
00106        /* close everything */
00107        if (!list) list = SUMA_CreateList();
00108        ED = SUMA_InitializeEngineListData(SE_CloseStream4All);
00109        if (!SUMA_RegisterEngineListCommand ( list, ED, 
00110                                           SEF_i, (void*)&cc,  
00111                                           SES_Suma, (void *)sv, NOPE,   
00112                                           SEI_Head, NULL)) {  
00113          fprintf (SUMA_STDERR, "Error %s: Failed to register command.\n", FuncName);   
00114        }
00115 
00116        if (!SUMA_Engine (&list)) {
00117          fprintf (SUMA_STDERR,"Error %s: Failed in SUMA_Engine.\n\a", FuncName);
00118        }      
00119       
00120        continue;  /* skip to next stream */
00121      }
00122 
00123      if (nn == 0) { /* waiting, come back later */
00124          continue;
00125      }
00126      
00127      /* if here, stream is good;
00128         see if there is any data to be read */
00129       
00130       if (SUMAg_CF->ns_flags_v[cc] & SUMA_FLAG_WAITING) {
00131          SUMAg_CF->ns_flags_v[cc] = SUMA_FLAG_CONNECTED;
00132          fprintf(SUMA_STDERR, "%s: ++ NIML connection opened from %s\n",
00133                   FuncName, NI_stream_name(SUMAg_CF->ns_v[cc])                ) ;
00134       }
00135    #if 0
00136       /* not good enough, checks socket only, not buffer */
00137       nn = NI_stream_readcheck( SUMAg_CF->ns , 1 ) ;
00138    #else
00139       nn = NI_stream_hasinput( SUMAg_CF->ns_v[cc] , 1 ) ;
00140    #endif
00141    
00142      if( nn > 0 ){                                   /* has data */
00143        int ct = NI_clock_time() ;
00144        if (LocalHead)   fprintf(SUMA_STDERR,"%s: reading data stream", FuncName) ;
00145 
00146        nini = NI_read_element( SUMAg_CF->ns_v[cc] , 1 ) ;  /* read it */
00147          #if SUMA_SUMA_NIML_DEBUG /* debugging corruption of niml ...*/
00148             nel = (NI_element *)nini ;
00149             if( strcmp(nel->name,"SUMA_irgba") == 0 || strcmp(nel->name,"Node_RGBAb") == 0) 
00150             {
00151                int *ibad=NULL;
00152                
00153                ibad = (int *)nel->vec[0]; 
00154                if (ibad[0] > 1000) {
00155                   fprintf (SUMA_STDERR,"**********\n\tibad[0] = %d\n****************\n", ibad[0]);
00156                   fprintf (SUMA_STDOUT,"********** ibad[0] = %d ****************", ibad[0]);
00157                }
00158                if( nel->vec_len  < 1 || nel->vec_filled <  1) {  /* empty element?             */
00159                   fprintf(SUMA_STDERR,"--------\n\tEmpty SUMA_irgba (len = %d, len = %d)\n--------\n", 
00160                      nel->vec_len, nel->vec_filled);
00161                   fprintf(SUMA_STDOUT,"-------- Empty SUMA_irgba (len = %d, filled = %d) --------", 
00162                      nel->vec_len, nel->vec_filled);
00163                }
00164                fprintf (SUMA_STDOUT,"\n");
00165             }
00166          #endif
00167          
00168        if (LocalHead)   fprintf(SUMA_STDERR," time=%d ms\n",NI_clock_time()-ct) ; ct = NI_clock_time() ;
00169 
00170        if( nini != NULL ) {
00171          nel = (NI_element *)nini ;
00172          if (SUMAg_CF->TrackingId_v[cc]) {
00173             nel_track = NI_get_attribute(nel,"Tracking_ID");
00174             if (nel_track) {
00175                id = atoi(nel_track);
00176                if (id != SUMAg_CF->TrackingId_v[cc] + 1) {
00177                   /* remember, "StartTracking" nel is the #1 element, first data element starts at 2 */
00178                   fprintf (SUMA_STDERR,"Warning %s:\n Expected element %d, received element %d.\n",
00179                            FuncName,  SUMAg_CF->TrackingId_v[cc] + 1 , id );
00180                   SUMA_BEEP;
00181                }
00182                SUMAg_CF->TrackingId_v[cc] = id;
00183             }
00184          }
00185          if (LocalHead)   {
00186             fprintf(SUMA_STDERR,"%s:     name=%s vec_len=%d vec_filled=%d, vec_num=%d\n", FuncName,\
00187                   nel->name, nel->vec_len, nel->vec_filled, nel->vec_num );
00188          }      
00189           if (!SUMA_process_NIML_data( nini , sv)) {
00190              fprintf(SUMA_STDERR,"Error %s: Failed in SUMA_process_NIML_data.\n", FuncName);
00191           }
00192       }
00193 
00194       NI_free_element( nini ) ;
00195 
00196       if (LocalHead)   fprintf(SUMA_STDERR,"processing time=%d ms\n",NI_clock_time()-ct) ;
00197 
00198      } 
00199    
00200    }/* for cc*/
00201    
00202    if (ngood == 0) {
00203       SUMAg_CF->niml_work_on = NOPE;
00204       SUMAg_CF->Listening = NOPE;
00205       if (SUMA_NIML_WORKPROC_IO_NOTIFY) {
00206          SUMA_RETURN(True) ;  /* don't call me back */
00207       }
00208          else return (True);
00209    }
00210    
00211    if (SUMA_NIML_WORKPROC_IO_NOTIFY) {
00212       SUMA_RETURN(False) ;  /* call me back baby*/
00213    }
00214       else return (False);
00215 }

01764 {
01765    static char FuncName[]={"SUMA_NIMLDrawnROI_to_DrawnROI"};
01766    SUMA_ROI_ACTION_STRUCT *ROIA=NULL;
01767    SUMA_DRAWN_ROI *ROI = NULL;
01768    SUMA_ROI_DATUM *ROI_Datum = NULL;
01769    DListElmt *tmpStackPos=NULL;
01770    int i;
01771    SUMA_Boolean LocalHead = NOPE;
01772    
01773    SUMA_ENTRY;
01774    
01775    if (!nimlROI) SUMA_RETURN(NULL);
01776    
01777    /* allocate and initialize the whimpy fields 
01778       Based on SUMA_AllocateDrawnROI*/
01779    ROI = (SUMA_DRAWN_ROI *) SUMA_malloc(sizeof(SUMA_DRAWN_ROI));
01780    if (  nimlROI->Type == SUMA_ROI_OpenPath || 
01781          nimlROI->Type == SUMA_ROI_ClosedPath ||
01782          nimlROI->Type == SUMA_ROI_FilledArea ) { /* this ROI will gradually be reconstructed,
01783                                                        start with the basics */
01784          ROI->Type = SUMA_ROI_OpenPath; /* at the end of the construction you should reach nimlROI->Type */
01785    }else {
01786       /* nothing to reconstruct */
01787       ROI->Type = nimlROI->Type;
01788    }
01789    
01790    ROI->idcode_str = SUMA_copy_string(nimlROI->idcode_str);
01791    ROI->Parent_idcode_str = SUMA_copy_string(nimlROI->Parent_idcode_str);
01792    ROI->Label = SUMA_copy_string(nimlROI->Label);
01793    ROI->iLabel = nimlROI->iLabel;
01794    if (LocalHead) fprintf (SUMA_STDERR, "%s: ROI->Parent_idcode_str %s\n", FuncName, ROI->Parent_idcode_str);
01795    
01796    ROI->ROIstrokelist = (DList *)SUMA_malloc (sizeof(DList));
01797    dlist_init(ROI->ROIstrokelist, SUMA_FreeROIDatum);
01798    
01799    ROI->DrawStatus = SUMA_ROI_Finished;
01800    ROI->StackPos = NULL;
01801    ROI->ActionStack = SUMA_CreateActionStack ();
01802    ROI->ColPlaneName = SUMA_copy_string(nimlROI->ColPlaneName);
01803    ROI->FillColor[0] = nimlROI->FillColor[0];
01804    ROI->FillColor[1] = nimlROI->FillColor[1];
01805    ROI->FillColor[2] = nimlROI->FillColor[2];
01806    ROI->EdgeColor[0] = nimlROI->EdgeColor[0];
01807    ROI->EdgeColor[1] = nimlROI->EdgeColor[1];
01808    ROI->EdgeColor[2] = nimlROI->EdgeColor[2];
01809    ROI->EdgeThickness = nimlROI->EdgeThickness;
01810    ROI->CE = NULL;
01811    ROI->N_CE = -1;
01812    /* fill in the ROI datum stuff */
01813    for (i=0; i<nimlROI->N_ROI_datum; ++i) {
01814          ROI_Datum = SUMA_AllocROIDatum ();
01815          ROI_Datum->action = nimlROI->ROI_datum[i].action;
01816          ROI_Datum->nPath = nimlROI->ROI_datum[i].nPath;
01817          ROI_Datum->Type = nimlROI->ROI_datum[i].Type;
01818          ROI_Datum->N_n = nimlROI->ROI_datum[i].N_n;
01819       if (ForDisplay) { /* create DO/UNDO stack */
01820          ROIA = (SUMA_ROI_ACTION_STRUCT *) SUMA_malloc (sizeof(SUMA_ROI_ACTION_STRUCT));
01821          ROIA->DrawnROI = ROI;
01822          ROIA->ROId = ROI_Datum;
01823          switch (ROI_Datum->action) {
01824             case SUMA_BSA_AppendStroke:
01825                SUMA_LH("Appending Stroke Action");
01826                tmpStackPos = SUMA_PushActionStack (ROI->ActionStack, ROI->StackPos, 
01827                   SUMA_AddToTailROIDatum, (void *)ROIA, SUMA_DestroyROIActionData);
01828                break;
01829             case SUMA_BSA_JoinEnds:
01830                SUMA_LH("Join Ends Action");
01831                tmpStackPos = SUMA_PushActionStack (ROI->ActionStack, ROI->StackPos, 
01832                   SUMA_AddToTailJunctionROIDatum, (void *)ROIA, SUMA_DestroyROIActionData);
01833                break;
01834             case SUMA_BSA_FillArea:
01835                SUMA_LH("Fill Area Action");
01836                tmpStackPos = SUMA_PushActionStack (ROI->ActionStack, ROI->StackPos, 
01837                   SUMA_AddFillROIDatum, (void *)ROIA, SUMA_DestroyROIActionData);
01838                break;
01839             default:
01840                fprintf (SUMA_STDERR, "Error %s: Not ready to deal with this action (%d).\n", 
01841                   FuncName, ROI_Datum->action);
01842                break; 
01843 
01844          }
01845 
01846          if (tmpStackPos) ROI->StackPos = tmpStackPos;
01847          else {
01848             fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_PushActionStack.\n", FuncName);
01849          }
01850       } else {
01851          /* ROI will not be used for display purposes, just add datum */
01852          dlist_ins_next(ROI->ROIstrokelist, dlist_tail(ROI->ROIstrokelist), (void *)ROI_Datum);
01853       }
01854    }
01855    
01856    if (ForDisplay) {
01857       /* Saved ROIs are considered finished, put a finish action on the top of the action stack */
01858       ROIA = (SUMA_ROI_ACTION_STRUCT *) SUMA_malloc (sizeof(SUMA_ROI_ACTION_STRUCT)); 
01859       ROIA->DrawnROI = ROI;
01860       ROIA->ROId = NULL;
01861       tmpStackPos = SUMA_PushActionStack (ROI->ActionStack, ROI->StackPos, 
01862                   SUMA_FinishedROI, (void *)ROIA, SUMA_DestroyROIActionData);
01863       if (tmpStackPos) ROI->StackPos = tmpStackPos;
01864       else {
01865          SUMA_SL_Err("Failed in SUMA_PushActionStack.\n");
01866          SUMA_RETURN(NULL);
01867       } 
01868    }   
01869    SUMA_RETURN(ROI);
01870 }

02818 {
02819    static char FuncName[]={"SUMA_NodeVal2irgba_nel"};
02820    static int i_in=0, *node=NULL;
02821    static SUMA_COLOR_MAP *CM=NULL;
02822    static SUMA_SCALE_TO_MAP_OPT * OptScl=NULL;
02823    static SUMA_STANDARD_CMAP MapType;
02824    static SUMA_COLOR_SCALED_VECT * SV=NULL;
02825    static byte *rgba=NULL;
02826    static char past_instance[50]={""};
02827    char idcode_str[50];
02828    NI_element *nel=NULL;
02829    int i, i4, i3; 
02830    float IntRange[2], *Vsort= NULL;
02831    SUMA_Boolean LocalHead = NOPE;
02832     
02833    SUMA_ENTRY;
02834    
02835    if (cleanup == 1) {
02836       SUMA_LH("Cleanup...");
02837       SUMA_NODEVAL2IRGBA_CLEANUP;
02838       past_instance[0]='\0';
02839       i_in = 0;
02840       SUMA_RETURN(NULL);
02841    }
02842 
02843    if (!instanceID) {
02844       SUMA_SL_Err("This function requires instanceID to be non-null.");
02845       SUMA_RETURN(NULL);
02846    }
02847    
02848    if (strcmp(instanceID, past_instance)) {
02849       SUMA_LH("A new instance"); 
02850       /* clean up if necessary */
02851       if (i_in) SUMA_NODEVAL2IRGBA_CLEANUP;
02852       i_in = 0;
02853       sprintf(past_instance,"%s", instanceID);
02854    }
02855    
02856    
02857        
02858    if (!i_in) {
02859       /* first time around */
02860       /* create the color mapping of Cx (SUMA_CMAP_MATLAB_DEF_BYR64)*/
02861       CM = SUMA_GetStandardMap (SUMA_CMAP_MATLAB_DEF_BYR64);
02862       if (CM == NULL) {
02863          fprintf (SUMA_STDERR,"Error %s: Could not get standard colormap.\n", FuncName); 
02864          SUMA_RETURN (NULL);
02865       }
02866 
02867       /* get the options for creating the scaled color mapping */
02868       OptScl = SUMA_ScaleToMapOptInit();
02869       if (!OptScl) {
02870          fprintf (SUMA_STDERR,"Error %s: Could not get scaling option structure.\n", FuncName);
02871          SUMA_RETURN (NULL); 
02872       }
02873 
02874       /* work the options a bit */
02875       OptScl->ApplyClip = NOPE;
02876       OptScl->MaskZero = NOPE;
02877       IntRange[0] = 0; IntRange[1] = 100; /* percentile clipping range*/ 
02878       Vsort = SUMA_PercRange (val, NULL, SO->N_Node, IntRange, IntRange, NULL); 
02879       if (Vsort[0] < 0 && Vsort[SO->N_Node -1] > 0 ) {
02880          /* the new method */
02881          if (fabs(IntRange[0]) > IntRange[1]) {
02882             IntRange[1] = -IntRange[0];
02883          } else {
02884             IntRange[0] = -IntRange[1];
02885          }
02886       } 
02887       OptScl->IntRange[0] = IntRange[0]; OptScl->IntRange[1] = IntRange[1];
02888       OptScl->BrightFact = 1.0;
02889 
02890       /* create structure to hold the colored values */
02891       SV = SUMA_Create_ColorScaledVect(SO->N_Node);/* allocate space for the result */
02892       if (!SV) {
02893          fprintf (SUMA_STDERR,"Error %s: Could not allocate for SV.\n", FuncName);
02894          SUMA_RETURN (NULL);
02895       }
02896       
02897       /* node vector */
02898       node = (int *) SUMA_malloc(sizeof(int) * SO->N_Node);
02899       /* color vectors to hold RGBA colors*/
02900       rgba = (byte *) SUMA_malloc(sizeof(byte) * SO->N_Node * 4);
02901       if (!node || !rgba) {
02902          SUMA_SL_Err("Failed to allocate for node or rgba.");
02903          SUMA_RETURN(NULL);
02904       }
02905       for (i=0; i < SO->N_Node; ++i) node[i] = i;
02906       
02907       if (Vsort) SUMA_free(Vsort); Vsort = NULL;
02908    }
02909     
02910    /* map the values in val to the colormap */
02911 
02912    /* finally ! */
02913    if (!SUMA_ScaleToMap (val, SO->N_Node, OptScl->IntRange[0], OptScl->IntRange[1], CM, OptScl, SV)) {
02914       fprintf (SUMA_STDERR,"Error %s: Failed in SUMA_ScaleToMap.\n", FuncName);
02915       SUMA_RETURN (NOPE);
02916    }             
02917                
02918    /* copy the colors to rgba */
02919    for (i=0; i < SO->N_Node; ++i) {
02920       i4 = 4 * i;
02921       i3 = 3 *i;
02922       rgba[i4] = (byte)(SV->cV[i3  ] * 255); ++i4;
02923       rgba[i4] = (byte)(SV->cV[i3+1] * 255); ++i4;
02924       rgba[i4] = (byte)(SV->cV[i3+2] * 255); ++i4;
02925       rgba[i4] = 255;
02926    }
02927    
02928    /* now create the niml element */
02929    UNIQ_idcode_fill (idcode_str);
02930    /* Now create that data element and write it out */
02931    SUMA_allow_nel_use(1);
02932    nel = SUMA_NewNel (  SUMA_NODE_RGBAb, /* one of SUMA_DSET_TYPE */
02933                         SO->idcode_str, /* idcode of Domain Parent */
02934                         NULL, /* idcode of geometry parent, not useful here*/
02935                         SO->N_Node,/* Number of elements */
02936                         NULL, NULL); 
02937    if (!nel) {
02938       fprintf (stderr,"Error  %s:\nFailed in SUMA_NewNel", FuncName);
02939       SUMA_RETURN(NULL);
02940    }
02941    /* set the surface idcode attribute */
02942    NI_set_attribute (nel, "surface_idcode", SO->idcode_str);   
02943    
02944    /* Add the columns */
02945    SUMA_allow_nel_use(1);
02946    if (!SUMA_AddNelCol (nel, /* the famed nel */ 
02947                         "node index", 
02948                         SUMA_NODE_INDEX, /* the column's type (description),
02949                                             one of SUMA_COL_TYPE */
02950                         (void *)node, /* the list of node indices */
02951                         NULL  /* that's an optional structure containing 
02952                                  attributes of the added column. 
02953                                  Not used at the moment */
02954                         ,1 /* stride, useful when you need to copy a column
02955                               from a multiplexed vector. Say you have in p 
02956                               [rgb rgb rgb rgb], to get the g column you 
02957                               send in p+1 for the column pointer and a stride
02958                               of 3 */
02959                         )) {
02960       fprintf (stderr,"Error  %s:\nFailed in SUMA_AddNelCol", FuncName);
02961       SUMA_RETURN(NULL);                    
02962    }
02963 
02964    /* insert from multiplexed rgb vector */
02965    SUMA_allow_nel_use(1);
02966    if (!SUMA_AddNelCol (nel, "red", SUMA_NODE_Rb, (void *)rgba, NULL ,4 )) {
02967       fprintf (stderr,"Error  %s:\nFailed in SUMA_AddNelCol", FuncName);
02968       SUMA_RETURN(NULL);
02969    }
02970 
02971    SUMA_allow_nel_use(1);
02972    if (!SUMA_AddNelCol (nel, "green", SUMA_NODE_Gb, (void *)(rgba+1), NULL ,4)) {
02973       fprintf (stderr,"Error  %s:\nFailed in SUMA_AddNelCol", FuncName);
02974       SUMA_RETURN(NULL);
02975    }
02976 
02977    SUMA_allow_nel_use(1);
02978    if (!SUMA_AddNelCol (nel, "blue", SUMA_NODE_Bb, (void *)(rgba+2), NULL ,4)) {
02979       fprintf (stderr,"Error  %s:\nFailed in SUMA_AddNelCol", FuncName);
02980       SUMA_RETURN(NULL);
02981    }
02982    
02983    SUMA_allow_nel_use(1);
02984    if (!SUMA_AddNelCol (nel, "alpha", SUMA_NODE_Ab, (void *)(rgba+3), NULL ,4)) {
02985       fprintf (stderr,"Error  %s:\nFailed in SUMA_AddNelCol", FuncName);
02986       SUMA_RETURN(NULL);
02987    }
02988    
02989    
02990    ++i_in; 
02991    
02992    if (cleanup == -1) {
02993       SUMA_LH("Last or one call only cleanup");
02994       SUMA_NODEVAL2IRGBA_CLEANUP;
02995       past_instance[0]='\0';
02996       i_in = 0;
02997    }
02998          
02999    /* return the element */
03000    SUMA_RETURN(nel); 
03001                
03002 } 

02465 {
02466    static char FuncName[]={"SUMA_NodeXYZ2NodeXYZ_nel"};
02467    static int i_in=0;
02468    char stmp[500];
02469    NI_element *nel=NULL;
02470    SUMA_Boolean LocalHead = NOPE;
02471    
02472    SUMA_ENTRY;
02473    
02474    if (dtype != SUMA_NEW_NODE_XYZ && dtype != SUMA_NODE_XYZ) {
02475       SUMA_SL_Err("Bad dtype for this function!");
02476       SUMA_RETURN(NULL);
02477    }
02478    
02479    if (cleanup) {
02480       SUMA_LH("Cleanup...");
02481       SUMA_RETURN(NULL);
02482    }
02483    
02484    if (SO->NodeDim != 3) { /* only deals with XYZ for the moment */
02485       SUMA_SL_Err("NodeDim must be 3!");
02486       SUMA_RETURN(nel);
02487    }
02488    
02489    if (!i_in) {
02490       /* Initialization block. Nothing to do , really */
02491       
02492    }
02493    
02494    
02495    /* Now create that data element and write it out */
02496    SUMA_allow_nel_use(1);
02497    nel = SUMA_NewNel (  dtype, /* one of SUMA_DSET_TYPE */
02498                         SO->idcode_str, /* idcode of Domain Parent Surface*/
02499                         NULL, /* idcode of geometry parent, not useful here*/
02500                         3*SO->N_Node,
02501                         NULL,
02502                         SO->nodelist_idcode_str); 
02503    if (!nel) {
02504       fprintf (stderr,"Error  %s:\nFailed in SUMA_NewNel", FuncName);
02505       SUMA_RETURN(NULL);
02506    }
02507    
02508    sprintf(stmp, "%d", SO->NodeDim);
02509    NI_set_attribute (nel, "Node_Dim", stmp);
02510 
02511    #if 0 /* no longer needed */
02512    /* set the surface idcode attribute */
02513    NI_set_attribute (nel, "surface_idcode", SO->idcode_str);   
02514    #endif
02515    
02516    /* set the label */
02517    if (SO->Label) {
02518       sprintf(stmp, "NodeList for surface %s", SO->Label);
02519       NI_set_attribute (nel, "Object_Label", stmp);
02520    } else {
02521       NI_set_attribute (nel, "Object_Label", SUMA_EMPTY_ATTR);
02522    }
02523          
02524    #if 0 /* old way */
02525    /* Add the coordinate column */
02526    if (!SUMA_AddNelCol (nel, /* the famed nel */ 
02527                         "XYZ coords", 
02528                         SUMA_NODE_3C, /* the column's type (description),
02529                                             one of SUMA_COL_TYPE */
02530                         (void *)val, /* the coordinates */
02531                         NULL  /* that's an optional structure containing 
02532                                  attributes of the added column. 
02533                                  Not used at the moment */
02534                         ,1
02535                         )) {
02536       fprintf (stderr,"Error  %s:\nFailed in SUMA_AddNelCol", FuncName);
02537       SUMA_RETURN(NULL);                    
02538    }
02539    #else /* new way, no need for embellishments */
02540       NI_add_column_stride ( nel, NI_FLOAT, val, 1 );
02541    #endif
02542    ++i_in; 
02543          
02544    /* return the element */
02545    SUMA_RETURN(nel); 
02546 
02547    
02548 }

02399 {
02400    static char FuncName[]={"SUMA_NodeXYZ_nel2NodeXYZ"};
02401    char *tmp = NULL;
02402    SUMA_DSET_TYPE dtype;
02403    SUMA_Boolean LocalHead = NOPE;
02404    
02405    SUMA_ENTRY;
02406    
02407    dtype = SUMA_Dset_Type(nel->name);
02408    
02409    if (dtype != SUMA_NODE_XYZ && dtype != SUMA_NEW_NODE_XYZ) {
02410       SUMA_SL_Err("Bad nel for this function");
02411       SUMA_RETURN(NOPE);
02412    }
02413    
02414    tmp = NI_get_attribute(nel, "Node_Dim");
02415    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) {
02416       SO->NodeDim = atoi(tmp);
02417       if (SO->NodeDim != 3) {
02418          SUMA_SL_Err("Not willing to deal with SO->NodeDim != 3");
02419          SUMA_RETURN(NOPE);
02420       }
02421    }
02422 
02423    tmp = NI_get_attribute(nel, "Object_ID");
02424    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->nodelist_idcode_str = SUMA_copy_string(tmp);
02425 
02426    tmp = NI_get_attribute(nel, "Parent_ID");
02427    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) {
02428       if (strcmp(tmp, SO->idcode_str)) {
02429          SUMA_SL_Err("idcode of parent mismatch"); SUMA_RETURN(NOPE);
02430       }
02431    }
02432 
02433    /* how many elements? */
02434    if (SO->N_Node) {
02435       if (SO->N_Node == nel->vec_len/SO->NodeDim) {
02436          if (!SO->NodeList) {
02437             SUMA_SL_Err("Bad initial values in SO. SO->N_Node == nel->vec_len/3 but NULL SO->NodeList");
02438             SUMA_RETURN(NOPE); 
02439          } 
02440       } else {
02441          /* gotta cleanup */
02442          if (SO->NodeList) SUMA_free(SO->NodeList); SO->NodeList = NULL; SO->N_Node = 0;
02443       }
02444    } else {
02445       if (SO->NodeList) { SUMA_SL_Err("Should not have a NodeList here"); SUMA_RETURN(NOPE); }
02446    }
02447    
02448    SO->N_Node = nel->vec_len/SO->NodeDim;
02449    if (!SO->NodeList) SO->NodeList = (float *)SUMA_malloc(nel->vec_len * sizeof(float));
02450    if (!SO->NodeList) {
02451       SUMA_SL_Crit("Failed to allocate"); SUMA_RETURN(NOPE); 
02452    }
02453    memcpy((void *)SO->NodeList, nel->vec[0], nel->vec_len * sizeof(float));
02454    
02455    SUMA_RETURN(YUP);
02456 }

01511 {
01512    static char FuncName[]={"SUMA_register_workproc"};
01513    
01514    SUMA_ENTRY;
01515 
01516    if( func == NULL ){
01517       fprintf(SUMA_STDERR,"Error %s: func=NULL on entry!\n", FuncName) ;
01518       SUMA_RETURNe;
01519    }
01520 
01521    if( num_workp == 0 ){
01522       workp = (XtWorkProc *) SUMA_malloc( sizeof(XtWorkProc) ) ;
01523       datap = (XtPointer *)  SUMA_malloc( sizeof(XtPointer) ) ;
01524       wpid  = XtAppAddWorkProc(SUMAg_CF->X->App, SUMA_workprocess, NULL ) ;
01525 #ifdef WPDEBUG
01526       fprintf(stderr,"SUMA_register_workproc: wpid = %x\n",(int)wpid) ;
01527 #endif
01528    } else {
01529       workp = (XtWorkProc *) SUMA_realloc( workp, sizeof(XtWorkProc)*(num_workp+1) ) ;
01530       datap = (XtPointer*)   SUMA_realloc( datap, sizeof(XtPointer) *(num_workp+1) ) ;
01531    }
01532 
01533    workp[num_workp] = func ;
01534    datap[num_workp] = data ;
01535    num_workp++ ;
01536 
01537 #ifdef WPDEBUG
01538 fprintf(stderr,"SUMA_register_workproc: have %d workprocs\n",num_workp) ;
01539 #endif
01540 
01541    SUMA_RETURNe ;
01542 }

01594 {
01595    int ii , ngood ;
01596    static char FuncName[]={"SUMA_remove_workproc"};
01597    
01598    SUMA_ENTRY;
01599 
01600    if( func == NULL || num_workp == 0 ){
01601       fprintf(SUMA_STDERR,"Error %s: *** illegal parameters!\n", FuncName) ;
01602       SUMA_RETURNe ;
01603    }
01604 
01605    if( num_workp < 1 ){
01606       #ifdef WPDEBUG
01607             fprintf(stderr,"SUMA_remove_workproc: No workprocs left\n") ;
01608       #endif
01609       XtRemoveWorkProc( wpid ) ;
01610       SUMA_free(workp) ; workp = NULL ; SUMA_free(datap) ; datap = NULL ;
01611       num_workp = 0 ;
01612    } else {
01613       for( ii=0 ; ii < num_workp ; ii++ ){
01614          if( func == workp[ii] ) {   /* move last Workprocess to location of workprocess to be deleted */
01615             workp[ii] = workp[num_workp-1] ;
01616             datap[ii] = datap[num_workp-1] ;
01617             workp[num_workp-1] = NULL;
01618             num_workp--;
01619          }
01620 
01621          #ifdef WPDEBUG
01622             fprintf(stderr,"SUMA_remove_workproc: %d workprocs left\n",ngood) ;
01623          #endif
01624       }
01625    }
01626 
01627    SUMA_RETURNe ;
01628 }

01549 {
01550    int ii , ngood ;
01551    static char FuncName[]={"SUMA_remove_workproc2"};
01552    SUMA_Boolean LocalHead = NOPE;
01553    
01554    SUMA_ENTRY;
01555 
01556    if (LocalHead)   fprintf (SUMA_STDERR, "%s: func = %p, num_workp = %d\n", FuncName, func, num_workp);
01557    
01558    if( func == NULL) {
01559       fprintf(SUMA_STDERR,"%s: *** illegal parameters!\n", FuncName) ;
01560       SUMA_RETURNe ;
01561    }
01562    if (num_workp == 0) {
01563       if (LocalHead)   fprintf(SUMA_STDERR,"%s: Nothing to do.\n", FuncName) ;
01564       SUMA_RETURNe ;
01565    }
01566    
01567    if( num_workp < 1 ){
01568       #ifdef WPDEBUG
01569             fprintf(SUMA_STDERR,"%s: No workprocs left\n", FuncName) ;
01570       #endif
01571       XtRemoveWorkProc( wpid ) ;
01572       SUMA_free(workp) ; workp = NULL ; SUMA_free(datap) ; datap = NULL ;
01573       num_workp = 0 ;
01574    } else {
01575       for( ii=0 ; ii < num_workp ; ii++ ){
01576          if( func == workp[ii] && data == datap[ii]) {   /* move last Workprocess to location of workprocess to be deleted */
01577             workp[ii] = workp[num_workp-1] ;
01578             datap[ii] = datap[num_workp-1] ;
01579             workp[num_workp-1] = NULL;
01580             num_workp--;
01581          }
01582 
01583          #ifdef WPDEBUG
01584             fprintf(SUMA_STDERR,"%s: %d workprocs left\n", FuncName, ngood) ;
01585          #endif
01586       }
01587    }
01588 
01589    SUMA_RETURNe ;
01590 
01591 }

03475 {
03476    static char FuncName[]={"SUMA_SendDset_Afni"};
03477    NI_group *ngr = NULL;
03478    NI_element *nel = NULL;
03479    int iv;
03480    SUMA_Boolean LocalHead = NOPE;
03481    
03482    SUMA_ENTRY;
03483    
03484    if (!dset) {
03485       SUMA_SL_Warn("NULL dset, nothing to do");
03486       SUMA_RETURN(YUP);
03487    }
03488    
03489    if (all == 1) {
03490       SUMA_LH("Sending all dset at once");
03491       ngr = THD_dataset_to_niml( dset ) ;
03492       NI_set_attribute( ngr , "AFNI_prefix" , DSET_PREFIX(dset) ) ;
03493       NI_write_element(ns, ngr, NI_BINARY_MODE);
03494       NI_free_element(ngr); ngr = NULL;
03495       SUMA_LH("Done.");
03496    } else {
03497       SUMA_SL_Warn("Sending one sub-brick at a time NOT TESTED IN SUMA YET");
03498       ngr = THD_nimlize_dsetatr( dset ) ;   /* header only */
03499       NI_set_attribute( ngr , "AFNI_prefix" , DSET_PREFIX(dset) ) ;
03500       NI_write_procins( ns , "keep_reading" ) ;
03501       NI_write_element( ns, ngr, NI_BINARY_MODE ) ;
03502       NI_free_element( ngr ) ; ngr = NULL;
03503       for( iv=0 ; iv < DSET_NVALS(dset) ; iv++ ){
03504          nel = THD_subbrick_to_niml( dset , iv , SBFLAG_INDEX ) ;
03505          NI_write_element( ns , nel , NI_BINARY_MODE ) ;
03506          NI_free_element(nel) ; nel = NULL;
03507       }
03508       NI_write_procins( ns , "pause_reading" ) ; /* not necessary but tidy */
03509    }
03510    
03511    
03512    SUMA_RETURN(YUP);
03513 }

02171 {
02172    static char FuncName[]={"SUMA_SendSumaNewSurface"};
02173    NI_group *ngr=NULL;
02174    
02175    SUMA_ENTRY;
02176    
02177    if (!SO || !cs) { SUMA_SL_Err("NULL surface or NULL cs"); SUMA_RETURN(NOPE); }
02178    if (!cs->Send || !cs->talk_suma) { SUMA_SL_Err("Nothing to do"); SUMA_RETURN(NOPE); }
02179    
02180    
02181     
02182    if (0) {
02183       /* send the mesh since this is a new surface */
02184       if (!SUMA_SendToSuma (SO, cs, (void *)SO->FaceSetList, SUMA_NEW_MESH_IJK, 1)) {
02185          SUMA_SL_Err("Failed to initialize SUMA_SendToSuma");
02186          cs->Send = NOPE;
02187          cs->talk_suma = NOPE;
02188          SUMA_RETURN(NOPE);
02189       }
02190       /* now send the coordinates of the new surface */
02191       if (!SUMA_SendToSuma (SO, cs, (void *)SO->NodeList, SUMA_NEW_NODE_XYZ, 1)) {
02192          SUMA_SL_Err("Failed to initialize SUMA_SendToSuma");
02193          cs->Send = NOPE;
02194          cs->talk_suma = NOPE;
02195          SUMA_RETURN(NOPE);
02196       }
02197       /* now send the command to register the new surface with viewers*/
02198       if (!SUMA_SendToSuma (SO, cs, NULL, SUMA_PREP_NEW_SURFACE, 1)) {
02199          SUMA_SL_Err("Failed to initialize SUMA_SendToSuma");
02200          cs->Send = NOPE;
02201          cs->talk_suma = NOPE;
02202          SUMA_RETURN(NOPE);
02203      }
02204       /* now manually clean up the function that created the new surface.
02205       last SUMA_SendToSuma call will only clean up the dtype that was being sent last.
02206       SUMA_SendToSuma can only clean when the same dtype is being sent. THAT NEEDS TO BE FIXED, perhaps send
02207       a flag to indicate how many objects you intend to send of any type. If it is one object
02208       then SendToSuma will do cleanup automatically without hangup ...*/
02209       SUMA_Mesh_IJK2Mesh_IJK_nel (SO, NULL, YUP, SUMA_NEW_MESH_IJK);
02210       SUMA_NodeXYZ2NodeXYZ_nel (SO, NULL, YUP, SUMA_NEW_NODE_XYZ);
02211    } else {
02212       /* the new way */
02213       ngr = SUMA_SO2nimlSO(SO, "NodeList, FaceSetList, VolPar", 1);
02214       if (!ngr) {
02215          SUMA_SL_Err("Failed to create surface");
02216          cs->Send = NOPE;
02217          cs->talk_suma = NOPE;
02218          SUMA_RETURN(NOPE);
02219       }
02220       /* now send the command to feed the new surface to suma*/
02221       if (!SUMA_SendToSuma (SO, cs, (void*)ngr, SUMA_SURFACE_OBJECT, 1)) {
02222          SUMA_SL_Err("Failed to initialize SUMA_SendToSuma");
02223          cs->Send = NOPE;
02224          cs->talk_suma = NOPE;
02225          SUMA_RETURN(NOPE);
02226       }
02227       
02228       /* now send the command to register the new surface with viewers*/
02229       if (!SUMA_SendToSuma (SO, cs, NULL, SUMA_PREP_NEW_SURFACE, 1)) {
02230          SUMA_SL_Err("Failed to initialize SUMA_SendToSuma");
02231          cs->Send = NOPE;
02232          cs->talk_suma = NOPE;
02233          SUMA_RETURN(NOPE);
02234       }
02235    }
02236    
02237    SUMA_RETURN(YUP);
02238 }

03377 {
03378    static char FuncName[]={"SUMA_SendToAfni"};
03379    static float etm = 0.0;
03380    static int i_in = 0;
03381    char stmp[500];
03382    struct  timeval tt;
03383    NI_element *nel=NULL;
03384    float *f=NULL;
03385    int n=-1, WaitClose, WaitMax, *ip = NULL;
03386    float wtm;
03387    SUMA_Boolean good = YUP;
03388    SUMA_Boolean LocalHead = NOPE;
03389    
03390    SUMA_ENTRY;
03391    
03392 
03393    if (action == 0) { /* initialization of connection */
03394       
03395       SUMA_LH("Setting up for communication with AFNI ...");
03396       cs->afni_Send = YUP;
03397       if(!SUMA_Assign_HostName (SUMAg_CF, cs->afni_host_name, cs->afni_istream)) {
03398                    fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_Assign_HostName", FuncName);
03399                    exit (1);
03400            }
03401       if (!SUMA_niml_call (SUMAg_CF, cs->afni_istream, NOPE)) {
03402          SUMA_SL_Err("Failed in SUMA_niml_call");
03403          /* connection flag is reset in SUMA_niml_call */
03404          cs->afni_Send = NOPE;
03405          SUMA_RETURN(NOPE);
03406       }
03407       
03408       /* no tracking for talking to AFNI */
03409       
03410       /* here is where you would start the workprocess for this program
03411       But since communication is one way, then forget about it */
03412       ++i_in;
03413       SUMA_RETURN(YUP);
03414    }
03415    
03416    if (action == 1) { /* action == 1,  send data mode */
03417       if (!i_in) {
03418          SUMA_SL_Err("You must call SUMA_SendToAfni with action 0 before action 1.\nNo Communcation cleanup done.");
03419          cs->afni_Send = NOPE;
03420          SUMA_RETURN(NOPE);
03421       }
03422       
03423       SUMA_LH("Creating nel and sending it");
03424       
03425       /* make sure stream is till OK */
03426       if (NI_stream_goodcheck ( SUMAg_CF->ns_v[cs->afni_istream] , 1 ) < 0) {
03427          cs->afni_GoneBad = YUP;
03428          SUMA_SL_Warn("Communication stream with afni gone bad.\nShutting down communication.");
03429          cs->afni_Send = NOPE;
03430          SUMA_RETURN(YUP); /* returning without error since program should continue */
03431       }
03432 
03433       if (!SUMA_SendDset_Afni( SUMAg_CF->ns_v[cs->afni_istream], (THD_3dim_dataset *)data, 1)) {
03434          SUMA_SL_Err("Failed to send dset");
03435          cs->afni_Send = NOPE;
03436          SUMA_RETURN(NOPE);
03437       }
03438       
03439       ++i_in;
03440       SUMA_RETURN(YUP);
03441    }/* action == 1 */
03442    
03443    if (action == 2) {
03444       if (i_in < 2) {
03445          SUMA_SL_Err("You must call SUMA_SendToAfni with action 0 and 1 before action 2.\nNo Communcation cleanup done.");
03446          cs->afni_Send = NOPE;
03447          SUMA_RETURN(NOPE);
03448       }
03449       /* reset static variables */
03450          i_in = 0;
03451          etm = 0.0;
03452          
03453       /* now close the stream*/
03454       if (cs->afni_Send && !cs->afni_GoneBad) { 
03455          SUMA_LH("Cleanup of nel producing functions...");
03456       
03457          NI_stream_close(SUMAg_CF->ns_v[cs->afni_istream]);
03458          SUMAg_CF->ns_v[cs->afni_istream] = NULL;
03459          SUMAg_CF->ns_flags_v[cs->afni_istream] = 0;
03460          SUMAg_CF->TrackingId_v[cs->afni_istream] = 0;
03461          cs->afni_Send = NOPE;
03462          cs->afni_GoneBad = NOPE;
03463          cs->afni_istream = -1;
03464       }
03465    
03466       SUMA_RETURN(YUP);
03467    }
03468 
03469    /* should not get here */
03470    SUMA_SL_Err("Flow error.\nThis should not be");
03471    SUMA_RETURN(NOPE);
03472 }

03040 {
03041    static char FuncName[]={"SUMA_SendToSuma"};
03042    static float etm = 0.0;
03043    static int i_in = 0;
03044    char stmp[500];
03045    struct  timeval tt;
03046    NI_element *nel=NULL;
03047    NI_group *ngr = NULL;
03048    float *f=NULL;
03049    int n=-1, WaitClose, WaitMax, *ip = NULL;
03050    float wtm;
03051    SUMA_Boolean good = YUP;
03052    SUMA_Boolean LocalHead = NOPE;
03053    
03054    SUMA_ENTRY;
03055    
03056 
03057    if (action == 0) { /* initialization of connection */
03058       
03059       SUMA_LH("Setting up for communication with SUMA ...");
03060       cs->Send = YUP;
03061       if(!SUMA_Assign_HostName (SUMAg_CF, cs->suma_host_name, cs->istream)) {
03062                    fprintf (SUMA_STDERR, "Error %s: Failed in SUMA_Assign_HostName", FuncName);
03063                    exit (1);
03064            }
03065       if (!SUMA_niml_call (SUMAg_CF, cs->istream, NOPE)) {
03066          SUMA_SL_Err("Failed in SUMA_niml_call");
03067          /* connection flag is reset in SUMA_niml_call */
03068          cs->Send = NOPE;
03069          SUMA_RETURN(NOPE);
03070       }
03071 
03072       nel = NI_new_data_element("StartTracking", 0); 
03073       cs->TrackID = 1; /* that's the index for StartTracking command */
03074       NI_set_attribute(nel,"ni_stream_name",  SUMAg_CF->NimlStream_v[cs->istream]);
03075       sprintf(stmp, "%d", cs->TrackID);
03076       NI_set_attribute(nel,"Tracking_ID", stmp);
03077       if (NI_write_element( SUMAg_CF->ns_v[cs->istream] , nel, cs->comm_NI_mode ) < 0) {
03078          SUMA_SL_Err("Failed to start tracking.\nContinuing...");
03079       } 
03080       if (nel) NI_free_element(nel); nel = NULL;
03081       
03082       /* here is where you would start the workprocess for this program
03083       But since communication is one way, then forget about it */
03084       ++i_in;
03085       SUMA_RETURN(YUP);
03086    }
03087    
03088    if (action == 1) { /* action == 1,  send data mode */
03089       if (!i_in) {
03090          SUMA_SL_Err("You must call SUMA_SendToSuma with action 0 before action 1.\nNo Communcation cleanup done.");
03091          cs->Send = NOPE;
03092          SUMA_RETURN(NOPE);
03093       }
03094       if ((cs->ElInd[dtype] % cs->kth)) {
03095          if (LocalHead) fprintf(SUMA_STDERR,"%s: Skipping element %d of type %d\n", FuncName, cs->ElInd[dtype], dtype);
03096          ++cs->ElInd[dtype];
03097          SUMA_RETURN(YUP);
03098       }
03099       ++cs->ElInd[dtype];
03100       SUMA_LH("Creating nel and sending it");
03101       switch (dtype) {
03102          case SUMA_NODE_RGBAb:
03103          case SUMA_NODE_XYZ:
03104          case SUMA_NEW_NODE_XYZ:
03105             n = 3 * SO->N_Node;
03106             f = (float *)data;
03107             break;
03108          case SUMA_NEW_MESH_IJK:
03109          case SUMA_MESH_IJK:
03110             n = 3 * SO->N_FaceSet;
03111             ip = (int *)data;
03112             break;
03113          case SUMA_PREP_NEW_SURFACE:
03114             break;
03115          case SUMA_SURFACE_OBJECT:
03116             break;
03117          default:
03118             SUMA_SL_Err("Data type not supported.");
03119             cs->GoneBad = YUP;
03120             cs->Send = NOPE;
03121             SUMA_RETURN(NOPE);
03122             break;
03123       }
03124 
03125       /* make sure stream is till OK */
03126       if (NI_stream_goodcheck ( SUMAg_CF->ns_v[cs->istream] , 1 ) < 0) {
03127          cs->GoneBad = YUP;
03128          SUMA_SL_Warn("Communication stream gone bad.\nShutting down communication.");
03129          cs->Send = NOPE;
03130          SUMA_SEND_TO_SUMA_FUNC_CLEANUP;
03131          SUMA_RETURN(YUP); /* returning without error since program should continue */
03132       }
03133 
03134       
03135       nel = NULL; ngr = NULL;
03136       switch (dtype) {
03137          case SUMA_NODE_RGBAb:
03138             /* colorize data */
03139             nel = SUMA_NodeVal2irgba_nel (SO, f, SO->idcode_str, 0);
03140             if (!nel) {
03141                SUMA_SL_Err("Failed in SUMA_NodeVal2irgba_nel.\nCommunication off.")
03142                cs->Send = NOPE;
03143                SUMA_RETURN(NOPE);
03144             }
03145             break;
03146          case SUMA_NODE_XYZ:
03147          case SUMA_NEW_NODE_XYZ:
03148             /* turn XYZ to nel  */
03149             nel =  SUMA_NodeXYZ2NodeXYZ_nel(SO, f, NOPE, dtype);
03150             if (!nel) {
03151                SUMA_SL_Err("Failed in SUMA_NodeXYZ2NodeXYZ_nel.\nCommunication off.")
03152                cs->Send = NOPE;
03153                SUMA_RETURN(NOPE);
03154             }
03155             if (cs->Feed2Afni) NI_set_attribute(nel, "Send2Afni", "DoItBaby");
03156             break;
03157          case SUMA_MESH_IJK:
03158          case SUMA_NEW_MESH_IJK:
03159             /* turn IJK to nel  */
03160             nel =  SUMA_Mesh_IJK2Mesh_IJK_nel(SO, ip, NOPE, dtype);
03161             if (!nel) {
03162                SUMA_SL_Err("Failed in SUMA_Mesh_IJK2Mesh_IJK_nel.\nCommunication off.")
03163                cs->Send = NOPE;
03164                SUMA_RETURN(NOPE);
03165             }
03166             break;
03167          case SUMA_PREP_NEW_SURFACE:
03168             nel = NI_new_data_element(SUMA_Dset_Type_Name(dtype), 0);
03169             NI_set_attribute (nel, "surface_idcode", SO->idcode_str);
03170             if (SO->VolPar) {
03171                char *vppref=NULL;
03172                vppref = SUMA_append_replace_string(SO->VolPar->dirname, SO->VolPar->filecode, "/", 0);
03173                NI_set_attribute(nel, "VolParFilecode", vppref); SUMA_free(vppref); vppref = NULL;
03174                if (cs->Feed2Afni) NI_set_attribute(nel, "Send2Afni", "DoItBaby");
03175             }
03176             break;
03177          case SUMA_SURFACE_OBJECT:
03178             ngr = (NI_group *)data;
03179             break;
03180          default:
03181             SUMA_SL_Err("Unexpected element. Ignoring.");
03182             SUMA_RETURN(YUP);
03183             break;   
03184       }
03185       
03186         
03187       if (!nel && !ngr) {/* !nel */
03188          SUMA_SL_Err("Flow error.");
03189          SUMA_RETURN(NOPE);
03190       }else {/* !nel */
03191          if (nel && ngr) {
03192             SUMA_SL_Err("Flow error.");
03193             SUMA_RETURN(NOPE);
03194          }
03195          /* add tracking */
03196          ++cs->TrackID;
03197          sprintf(stmp,"%d", cs->TrackID);
03198          if (nel) {
03199             NI_set_attribute (nel, "Tracking_ID", stmp);
03200          } else if (ngr) {
03201             NI_set_attribute (ngr, "Tracking_ID", stmp);
03202          }
03203       }
03204       
03205       #if SUMA_SUMA_NIML_DEBUG /* writes every element to a text file for debugging ... */
03206       {
03207          NI_stream ns;  
03208          /* Test writing results in asc, 1D format */ 
03209          if (LocalHead) fprintf(stderr," %s:-\nWriting ascii 1D ...\n"
03210                         , FuncName);
03211          /* open the stream */
03212          sprintf(stmp, "file:niml_dbg_asc_TID_%d_.1D",cs->TrackID);
03213          ns = NI_stream_open( stmp , "w" ) ;
03214          if( ns == NULL ){
03215            fprintf (stderr,"Error  %s:\nCan't open Test_write_asc_1D!"
03216                         , FuncName); 
03217             SUMA_RETURN(NOPE);
03218          }
03219 
03220          if (nel) {
03221             /* write out the element */
03222             if (NI_write_element( ns , nel ,
03223                                   NI_TEXT_MODE | NI_HEADERSHARP_FLAG ) < 0) {
03224                fprintf (stderr,"Error  %s:\nFailed in NI_write_element"
03225                               , FuncName);
03226                SUMA_RETURN(NOPE);
03227             }
03228          } else if (ngr) {
03229             /* write out the element */
03230             if (NI_write_element( ns , ngr ,
03231                                   NI_TEXT_MODE | NI_HEADERSHARP_FLAG ) < 0) {
03232                fprintf (stderr,"Error  %s:\nFailed in NI_write_element"
03233                               , FuncName);
03234                SUMA_RETURN(NOPE);
03235             }
03236          }
03237 
03238          /* close the stream */
03239          NI_stream_close( ns ) ;
03240       }
03241       #endif
03242 
03243       if (cs->nelps > 0) { /* make sure that you are not sending elements too fast */
03244          if (!etm) etm = 100000.0; /* first pass, an eternity */
03245          else etm = SUMA_etime(&tt, 1);
03246          wtm = 1./cs->nelps - etm;
03247          if (wtm > 0) { /* wait */
03248             SUMA_LH("Sleeping to meet refresh rate...");
03249             NI_sleep((int)(wtm*1000));
03250          }
03251       }
03252 
03253       /* send it to SUMA */
03254       if (LocalHead) fprintf (SUMA_STDOUT,"Sending element %d...\n", cs->TrackID);
03255       if (nel) {
03256          if (NI_write_element( SUMAg_CF->ns_v[cs->istream] , nel, cs->comm_NI_mode ) < 0) {
03257             SUMA_LH("Failed updating SUMA...");
03258          }
03259       } else if (ngr) {
03260          if (NI_write_element( SUMAg_CF->ns_v[cs->istream] , ngr, cs->comm_NI_mode ) < 0) {
03261             SUMA_LH("Failed updating SUMA...");
03262          }
03263       }
03264       if (LocalHead) {
03265          if (cs->nelps > 0) fprintf (SUMA_STDOUT,"        element %d sent (%f sec)\n", cs->TrackID, SUMA_etime(&tt, 1));
03266          else fprintf (SUMA_STDOUT,"        element %d sent \n", cs->TrackID);
03267       }
03268       if (nel) NI_free_element(nel) ; nel = NULL;
03269       if (ngr) NI_free_element(ngr) ; ngr = NULL;
03270       
03271       if (cs->nelps > 0) SUMA_etime(&tt, 0); /* start the timer */
03272       ++i_in;
03273       SUMA_RETURN(YUP);
03274    }/* action == 1 */
03275    
03276    if (action == 2) {
03277       if (i_in < 2) {
03278          SUMA_SL_Err("You must call SUMA_SendToSuma with action 0 and 1 before action 2.\nNo Communcation cleanup done.");
03279          cs->Send = NOPE;
03280          SUMA_RETURN(NOPE);
03281       }
03282       /* reset static variables */
03283          i_in = 0;
03284          etm = 0.0;
03285          
03286       SUMA_SEND_TO_SUMA_FUNC_CLEANUP;      
03287       
03288       /* now close the stream*/
03289       if (cs->Send && !cs->GoneBad) { 
03290          SUMA_LH("Cleanup of nel producing functions...");
03291          /* stop tracking */
03292          nel = NI_new_data_element("StopTracking", 0);
03293          NI_set_attribute(nel,"ni_stream_name",  SUMAg_CF->NimlStream_v[cs->istream]);
03294 
03295          if (NI_write_element( SUMAg_CF->ns_v[cs->istream] , nel, cs->comm_NI_mode ) < 0) {
03296             SUMA_SL_Err("Failed to stop tracking.\nContinuing...");
03297          } 
03298          if (nel) NI_free_element(nel); nel = NULL;
03299 
03300          /* tell suma you're done with that stream */
03301          nel = NI_new_data_element("CloseKillStream",0);
03302          if (!nel) {
03303             SUMA_SL_Err("Failed to create nel");
03304             exit(1);
03305          }
03306 
03307          NI_set_attribute (nel, "ni_stream_name",  SUMAg_CF->NimlStream_v[cs->istream]);
03308          if (NI_write_element( SUMAg_CF->ns_v[cs->istream] , nel, cs->comm_NI_mode ) < 0) {
03309                         SUMA_LH("Failed updating SUMA...");
03310          }
03311          if (nel) NI_free_element(nel) ; nel = NULL;
03312 
03313 
03314          /* now wait till stream goes bad */
03315          good = YUP;
03316          WaitClose = 0;
03317          WaitMax = 5000;
03318          fprintf (SUMA_STDERR,"\nWaiting for SUMA to close stream .");
03319          while (good && WaitClose < WaitMax) {
03320             if (NI_stream_goodcheck(SUMAg_CF->ns_v[cs->istream], 1) <= 0) {
03321                good = NOPE;
03322             } else {
03323                SUMA_LH("Good Check OK. Sleeping for a second...");
03324                NI_sleep(1000);
03325                fprintf (SUMA_STDERR,".");
03326                WaitClose += 1000;
03327             }
03328          }
03329 
03330          if (WaitClose >= WaitMax) { 
03331             SUMA_SL_Warn("\nFailed to detect closed stream.\nClosing shop anyway...");  
03332          }else{
03333             fprintf (SUMA_STDERR,"Done.\n");
03334          }
03335       
03336          NI_stream_close(SUMAg_CF->ns_v[cs->istream]);
03337          SUMAg_CF->ns_v[cs->istream] = NULL;
03338          SUMAg_CF->ns_flags_v[cs->istream] = 0;
03339          SUMAg_CF->TrackingId_v[cs->istream] = 0;
03340          cs->Send = NOPE;
03341          cs->GoneBad = NOPE;
03342          cs->nelps = -1.0;
03343          cs->TrackID = 0;
03344          cs->istream = -1;
03345          
03346          
03347          
03348       }
03349    
03350       SUMA_RETURN(YUP);
03351    }
03352 
03353    /* should not get here */
03354    SUMA_SL_Err("Flow error.\nThis should not be");
03355    SUMA_RETURN(NOPE);
03356 }

02672 {
02673    static char FuncName[]={"SUMA_SOVolPar2VolPar_nel"};
02674    NI_element *nel=NULL;
02675    int ibuf3[3], i;
02676    float fbuf3[3];   
02677    char stmp[500];
02678    SUMA_Boolean LocalHead = NOPE;
02679    
02680    SUMA_ENTRY;
02681   
02682    if (dtype != SUMA_SURFACE_VOLUME_PARENT) {
02683       SUMA_SL_Err("Bad dtype for this function!");
02684       SUMA_RETURN(NULL);
02685    }
02686    
02687    if (!VolPar) {
02688       SUMA_SL_Err("NULL VolPar");
02689       SUMA_RETURN(NULL);
02690    }
02691    
02692    
02693    if (!VolPar->idcode_str) { SUMA_NEW_ID(VolPar->idcode_str, NULL); }
02694    
02695    /* Now create that data element and write it out */
02696    SUMA_allow_nel_use(1);
02697    nel = SUMA_NewNel (  dtype, /* one of SUMA_DSET_TYPE */
02698                         SO->idcode_str, /* idcode of Domain Parent Surface*/
02699                         NULL, /* idcode of geometry parent, not useful here*/
02700                         0,
02701                         NULL,
02702                         VolPar->idcode_str); 
02703    if (!nel) {
02704       fprintf (stderr,"Error  %s:\nFailed in SUMA_NewNel", FuncName);
02705       SUMA_RETURN(NULL);
02706    }
02707    
02708    if (SO->Label) {
02709       sprintf(stmp,"Volume parent of %s", SO->Label);
02710       NI_set_attribute(nel, "Object_Label", stmp);
02711    } else {
02712       NI_set_attribute(nel, "Object_Label", SUMA_EMPTY_ATTR);
02713    }
02714    
02715    sprintf(stmp,"%d", VolPar->isanat); 
02716    NI_set_attribute(nel, "isanat", stmp);
02717 
02718    sprintf(stmp,"%d", VolPar->Hand); 
02719    NI_set_attribute(nel, "axis_hand", stmp);   
02720    
02721    if (VolPar->prefix) NI_set_attribute(nel, "prefix", VolPar->prefix);
02722    else NI_set_attribute(nel, "prefix", SUMA_EMPTY_ATTR);
02723    
02724    if (VolPar->filecode) NI_set_attribute(nel, "filecode", VolPar->filecode);
02725    else NI_set_attribute(nel, "filecode", SUMA_EMPTY_ATTR);
02726    
02727    if (VolPar->dirname) NI_set_attribute(nel, "dirname", VolPar->dirname);
02728    else NI_set_attribute(nel, "dirname", SUMA_EMPTY_ATTR);
02729    
02730    if (VolPar->vol_idcode_str) NI_set_attribute(nel, "vol_idcode_str", VolPar->vol_idcode_str);
02731    else NI_set_attribute(nel, "vol_idcode_str", SUMA_EMPTY_ATTR);
02732       
02733    if (VolPar->vol_idcode_date) NI_set_attribute(nel, "vol_idcode_date", VolPar->vol_idcode_date);
02734    else NI_set_attribute(nel, "vol_idcode_date", SUMA_EMPTY_ATTR);
02735    
02736    sprintf(stmp, "%d %d %d", VolPar->nx, VolPar->ny, VolPar->nz);
02737    NI_set_attribute(nel, "nxyz", stmp);
02738    
02739    sprintf(stmp, "%d %d %d", VolPar->xxorient, VolPar->yyorient, VolPar->zzorient);
02740    NI_set_attribute(nel, "xyzorient", stmp);
02741    
02742    sprintf(stmp, "%f %f %f", VolPar->dx, VolPar->dy, VolPar->dz);
02743    NI_set_attribute(nel, "dxyz", stmp);
02744    
02745    sprintf(stmp, "%f %f %f", VolPar->xorg, VolPar->yorg, VolPar->zorg);
02746    NI_set_attribute(nel, "xyzorg", stmp);
02747    
02748    if (VolPar->VOLREG_CENTER_OLD) {
02749       stmp[0] = '\0';
02750       for (i=0; i<3; ++i) sprintf(stmp,"%s %f", stmp, VolPar->VOLREG_CENTER_OLD[i]);
02751       NI_set_attribute(nel, "VOLREG_CENTER_OLD", stmp);
02752    }
02753    if (VolPar->VOLREG_CENTER_BASE) {
02754       stmp[0] = '\0';
02755       for (i=0; i<3; ++i) sprintf(stmp,"%s %f", stmp, VolPar->VOLREG_CENTER_BASE[i]);
02756       NI_set_attribute(nel, "VOLREG_CENTER_BASE", stmp);
02757    }
02758    
02759    if (VolPar->VOLREG_MATVEC) {
02760       stmp[0] = '\0';
02761       for (i=0; i<12; ++i) sprintf(stmp,"%s %f", stmp, VolPar->VOLREG_MATVEC[i]);
02762       NI_set_attribute(nel, "VOLREG_MATVEC", stmp);
02763    }
02764    
02765    if (VolPar->TAGALIGN_MATVEC) {
02766       stmp[0] = '\0';
02767       for (i=0; i<12; ++i) sprintf(stmp,"%s %f", stmp, VolPar->TAGALIGN_MATVEC[i]);
02768       NI_set_attribute(nel, "TAGALIGN_MATVEC", stmp);
02769    }
02770 
02771    if (VolPar->ROTATE_MATVEC) {
02772       stmp[0] = '\0';
02773       for (i=0; i<12; ++i) sprintf(stmp,"%s %f", stmp, VolPar->ROTATE_MATVEC[i]);
02774       NI_set_attribute(nel, "ROTATE_MATVEC", stmp);
02775    }
02776    
02777    if (VolPar->ROTATE_CENTER_OLD) {
02778       stmp[0] = '\0';
02779       for (i=0; i<3; ++i) sprintf(stmp,"%s %f", stmp, VolPar->ROTATE_CENTER_OLD[i]);
02780       NI_set_attribute(nel, "ROTATE_CENTER_OLD", stmp);
02781    }
02782    if (VolPar->ROTATE_CENTER_BASE) {
02783       stmp[0] = '\0';
02784       for (i=0; i<3; ++i) sprintf(stmp,"%s %f", stmp, VolPar->ROTATE_CENTER_BASE[i]);
02785       NI_set_attribute(nel, "ROTATE_CENTER_BASE", stmp);
02786    }
02787    SUMA_RETURN(nel);  
02788 }

02554 {
02555    static char FuncName[]={"SUMA_VolPar_nel2SOVolPar"};
02556    char *tmp;
02557    float fv15[15];
02558    SUMA_DSET_TYPE dtype;
02559    SUMA_Boolean LocalHead = NOPE;
02560    
02561    SUMA_ENTRY;
02562   
02563    dtype = SUMA_Dset_Type(nel->name);
02564    if (dtype != SUMA_SURFACE_VOLUME_PARENT) {
02565       SUMA_SL_Err("Bad dtype for this function!");
02566       SUMA_RETURN(NOPE);
02567    }
02568    
02569    if (SO->VolPar) { SUMA_SL_Err("SO->VolPar must be NULL here"); SUMA_RETURN(NOPE); }
02570    SO->VolPar = SUMA_Alloc_VolPar();
02571    
02572    tmp = NI_get_attribute(nel, "Object_ID");
02573    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->VolPar->idcode_str = SUMA_copy_string(tmp);
02574 
02575    tmp = NI_get_attribute(nel, "Parent_ID");
02576    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) {
02577       if (strcmp(tmp, SO->idcode_str)) {
02578          SUMA_SL_Err("idcode of parent mismatch"); SUMA_RETURN(NOPE);
02579       }
02580    }
02581    
02582    tmp = NI_get_attribute(nel, "isanat"); 
02583    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->VolPar->isanat = atoi(tmp);
02584    
02585    tmp = NI_get_attribute(nel, "axis_hand"); 
02586    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->VolPar->Hand = atoi(tmp);
02587    
02588    tmp = NI_get_attribute(nel, "prefix"); 
02589    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->VolPar->prefix = SUMA_copy_string(tmp);
02590    
02591    tmp = NI_get_attribute(nel, "filecode"); 
02592    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->VolPar->filecode = SUMA_copy_string(tmp);
02593    
02594    tmp = NI_get_attribute(nel, "dirname"); 
02595    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->VolPar->dirname = SUMA_copy_string(tmp);
02596    
02597    tmp = NI_get_attribute(nel, "vol_idcode_str"); 
02598    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->VolPar->vol_idcode_str = SUMA_copy_string(tmp);
02599    
02600    tmp = NI_get_attribute(nel, "vol_idcode_date"); 
02601    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->VolPar->vol_idcode_date = SUMA_copy_string(tmp);
02602    
02603    tmp = NI_get_attribute(nel, "nxyz"); 
02604    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { SUMA_StringToNum(tmp, fv15, 3); SO->VolPar->nx = (int)fv15[0]; SO->VolPar->ny = (int)fv15[1];   SO->VolPar->nz = (int)fv15[2]; }
02605    
02606    tmp = NI_get_attribute(nel, "xyzorient"); 
02607    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { SUMA_StringToNum(tmp, fv15, 3); SO->VolPar->xxorient = (int)fv15[0]; SO->VolPar->yyorient = (int)fv15[1];   SO->VolPar->zzorient = (int)fv15[2]; }
02608 
02609    tmp = NI_get_attribute(nel, "dxyz"); 
02610    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { SUMA_StringToNum(tmp, fv15, 3); SO->VolPar->dx = fv15[0]; SO->VolPar->dy = fv15[1];   SO->VolPar->dz = fv15[2]; }
02611    
02612    tmp = NI_get_attribute(nel, "xyzorg"); 
02613    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { SUMA_StringToNum(tmp, fv15, 3); SO->VolPar->xorg = fv15[0]; SO->VolPar->yorg = fv15[1];   SO->VolPar->zorg = fv15[2]; }
02614       
02615    tmp = NI_get_attribute(nel, "VOLREG_CENTER_OLD"); 
02616    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { 
02617       SUMA_StringToNum(tmp, fv15, 3); 
02618       SO->VolPar->VOLREG_CENTER_OLD = (float*)SUMA_malloc(sizeof(float)*3);
02619       SUMA_COPY_VEC(fv15, SO->VolPar->VOLREG_CENTER_OLD, 2, float, float);
02620    }
02621    
02622    tmp = NI_get_attribute(nel, "VOLREG_CENTER_BASE"); 
02623    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { 
02624       SUMA_StringToNum(tmp, fv15, 3); 
02625       SO->VolPar->VOLREG_CENTER_BASE = (float*)SUMA_malloc(sizeof(float)*3);
02626       SUMA_COPY_VEC(fv15, SO->VolPar->VOLREG_CENTER_BASE, 2, float, float);
02627    }
02628    
02629    tmp = NI_get_attribute(nel, "VOLREG_MATVEC"); 
02630    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { 
02631       SUMA_StringToNum(tmp, fv15, 12); 
02632       SO->VolPar->VOLREG_MATVEC = (float*)SUMA_malloc(sizeof(float)*12);
02633       SUMA_COPY_VEC(fv15, SO->VolPar->VOLREG_MATVEC, 2, float, float);
02634    }
02635 
02636    tmp = NI_get_attribute(nel, "TAGALIGN_MATVEC"); 
02637    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { 
02638       SUMA_StringToNum(tmp, fv15, 12); 
02639       SO->VolPar->TAGALIGN_MATVEC = (float*)SUMA_malloc(sizeof(float)*12);
02640       SUMA_COPY_VEC(fv15, SO->VolPar->TAGALIGN_MATVEC, 2, float, float);
02641    }
02642 
02643    tmp = NI_get_attribute(nel, "ROTATE_MATVEC"); 
02644    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { 
02645       SUMA_StringToNum(tmp, fv15, 12); 
02646       SO->VolPar->ROTATE_MATVEC = (float*)SUMA_malloc(sizeof(float)*12);
02647       SUMA_COPY_VEC(fv15, SO->VolPar->ROTATE_MATVEC, 2, float, float);
02648    }
02649    
02650    tmp = NI_get_attribute(nel, "ROTATE_CENTER_OLD"); 
02651    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { 
02652       SUMA_StringToNum(tmp, fv15, 3); 
02653       SO->VolPar->ROTATE_CENTER_OLD = (float*)SUMA_malloc(sizeof(float)*3);
02654       SUMA_COPY_VEC(fv15, SO->VolPar->ROTATE_CENTER_OLD, 2, float, float);
02655    }
02656 
02657    tmp = NI_get_attribute(nel, "ROTATE_CENTER_BASE"); 
02658    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) { 
02659       SUMA_StringToNum(tmp, fv15, 3); 
02660       SO->VolPar->ROTATE_CENTER_BASE = (float*)SUMA_malloc(sizeof(float)*3);
02661       SUMA_COPY_VEC(fv15, SO->VolPar->ROTATE_CENTER_BASE, 2, float, float);
02662    }
02663  
02664    SUMA_RETURN(YUP);
02665 }

00218 {
00219    static char FuncName[]={"SUMA_which_stream_index"};
00220    int i;
00221    SUMA_Boolean LocalHead = NOPE;
00222    
00223    SUMA_ENTRY;
00224    
00225    for (i=0; i < SUMA_MAX_STREAMS; ++i) {
00226       if (strcmp(nel_stream_name, cf->NimlStream_v[i]) == 0) SUMA_RETURN(i);
00227    }   
00228    
00229    SUMA_RETURN(-1);
00230 }

01631 {
01632    static char FuncName[]={"SUMA_workprocess"};
01633    int ii , ngood ;
01634    Boolean done ;
01635 
01636    if (SUMA_WORKPROC_IO_NOTIFY) {SUMA_ENTRY;}
01637    
01638 #ifdef WPDEBUG
01639    { static int ncall=0 ;
01640      if( (ncall++) % 1000 == 0 )
01641        fprintf(stderr,"SUMA_workprocess: entry %d\n",ncall) ; }
01642 #endif
01643 
01644    if( num_workp == 0 ) {
01645       if (SUMA_WORKPROC_IO_NOTIFY) {
01646          SUMA_RETURN(True) ;
01647       }
01648          else return(True);
01649    }
01650 
01651    for( ii=0,ngood=0 ; ii < num_workp ; ii++ ){
01652       if( workp[ii] != NULL ){
01653          done = workp[ii]( datap[ii] ) ;
01654          if( done == True ) workp[ii] = NULL ;
01655          else               ngood++ ;
01656       }
01657    }
01658 
01659    if( ngood == 0 ){
01660 #ifdef WPDEBUG
01661       fprintf(stderr,"Found no workprocs left\n") ;
01662 #endif
01663       SUMA_free(workp) ; workp = NULL ; SUMA_free(datap) ; datap = NULL ;
01664       num_workp = 0 ;
01665       if (SUMA_WORKPROC_IO_NOTIFY) {
01666          SUMA_RETURN(True) ;
01667       }
01668          else return (True);
01669    }
01670    
01671    if (SUMA_WORKPROC_IO_NOTIFY) {
01672       SUMA_RETURN(False) ;
01673    }
01674       else return(False);
01675 }

06062 {
06063    static char FuncName[]={"SUMA_Write_DrawnROI_NIML"};
06064    char stmp[SUMA_MAX_NAME_LENGTH+20];
06065    char *newname=NULL;
06066    int i;
06067    NI_element *nel ;
06068    NI_stream ns ;
06069    SUMA_NIML_DRAWN_ROI *niml_ROI = NULL;
06070    SUMA_DRAWN_ROI *ROI = NULL;
06071    SUMA_Boolean WriteBin = NOPE, LocalHead = NOPE;
06072 
06073    SUMA_ENTRY;
06074 
06075    if (Format == SUMA_ASCII) WriteBin = NOPE;
06076    else if (Format == SUMA_BINARY) WriteBin = YUP;
06077    else {
06078       SUMA_SL_Err("Wrong format");
06079       SUMA_RETURN(NOPE);
06080    }
06081    
06082    if (SUMAg_CF->nimlROI_Datum_type < 0) {
06083       SUMA_SL_Err("Bad niml type code");
06084       SUMA_RETURN(NOPE);
06085    }
06086    if (LocalHead) fprintf(SUMA_STDERR, "%s: roi_type code = %d\n", FuncName, SUMAg_CF->nimlROI_Datum_type) ;
06087 
06088    /* add a .niml.roi extension */
06089    if (strlen(filename) >= SUMA_MAX_NAME_LENGTH-20) {
06090       SUMA_SLP_Err("Give me a break, what kind of a filename is this ?");
06091       SUMA_RETURN(NOPE);
06092    }
06093 
06094    sprintf(stmp,"file:%s", filename);
06095    newname = SUMA_Extension(stmp, ".niml.roi", NOPE); 
06096    SUMA_LH(newname);
06097    ns = NI_stream_open( newname , "w" ) ;
06098 
06099    /* write the various ROIs */
06100    for (i=0; i < N_ROI; ++i) {
06101       ROI = ROIv[i];
06102       if (!ROI) {
06103          SUMA_SL_Err("NULL ROI!");
06104          NI_stream_close( ns ) ; 
06105          SUMA_RETURN(NOPE);
06106       }
06107       /* Transform the ROI to niml friendly structure */
06108       if (!(niml_ROI = SUMA_DrawnROI_to_NIMLDrawnROI (ROI))) {
06109          SUMA_SL_Err("NULL niml_ROI!");
06110          NI_stream_close( ns ) ; 
06111          SUMA_RETURN(NOPE);
06112       }
06113  
06114       /* Now create a ni element */
06115       if (LocalHead) fprintf(SUMA_STDERR,"%s: Creating new element of %d segments\n", FuncName, niml_ROI->N_ROI_datum);
06116       nel = NI_new_data_element(SUMA_Dset_Type_Name(SUMA_NODE_ROI),  niml_ROI->N_ROI_datum);
06117 
06118       SUMA_LH("Adding column...");
06119       NI_add_column( nel , SUMAg_CF->nimlROI_Datum_type, niml_ROI->ROI_datum );
06120 
06121       SUMA_LH("Setting attributes...");
06122       NI_set_attribute (nel, "Object_ID", niml_ROI->idcode_str);
06123       NI_set_attribute (nel, "Parent_ID", niml_ROI->Parent_idcode_str);
06124       NI_set_attribute (nel, "Label", niml_ROI->Label);
06125       sprintf(stmp,"%d", niml_ROI->iLabel);
06126       NI_set_attribute (nel, "iLabel", stmp);
06127       sprintf(stmp,"%d", niml_ROI->Type);
06128       NI_set_attribute (nel, "Type", stmp);
06129       NI_set_attribute (nel, "ColPlaneName", niml_ROI->ColPlaneName);
06130       sprintf(stmp,"%f %f %f", niml_ROI->FillColor[0], niml_ROI->FillColor[1],
06131                               niml_ROI->FillColor[2]);
06132       NI_set_attribute (nel, "FillColor",stmp);
06133       sprintf(stmp,"%f %f %f", niml_ROI->EdgeColor[0], niml_ROI->EdgeColor[1],
06134                               niml_ROI->EdgeColor[2]);
06135       NI_set_attribute (nel, "EdgeColor",stmp);
06136       sprintf(stmp,"%d", niml_ROI->EdgeThickness);
06137       NI_set_attribute (nel, "EdgeThickness", stmp);                   
06138       
06139       if (LocalHead) SUMA_nel_stdout (nel);
06140 
06141       if (!WriteBin) {
06142          SUMA_LH ("Writing element, Text mode.");
06143          if (NI_write_element( ns , nel , NI_TEXT_MODE | NI_HEADERSHARP_FLAG ) < 0) {
06144            SUMA_SL_Err("Badness, failed to write nel");
06145            NI_stream_close( ns ) ; 
06146            SUMA_RETURN(NOPE);
06147          }
06148       } else {
06149          SUMA_LH ("Writing element, Binary mode.");
06150          if (NI_write_element( ns , nel , NI_BINARY_MODE) < 0) {
06151            SUMA_SL_Err("Badness, failed to write nel");
06152            NI_stream_close( ns ) ; 
06153            SUMA_RETURN(NOPE);
06154          }
06155       } 
06156 
06157       /* free nel */
06158       NI_free_element(nel) ; nel = NULL;
06159 
06160       /* free the niml_ROI structure */
06161       niml_ROI = SUMA_Free_NIMLDrawROI (niml_ROI); niml_ROI = NULL;
06162       
06163    }
06164    
06165    NI_stream_close( ns ) ; 
06166    
06167    if (newname) SUMA_free(newname);
06168    
06169    SUMA_RETURN(YUP);
06170 }