( (  tp == SUMA_int || \
                                          tp == SUMA_float ||  \
                                          tp == SUMA_double || \
                                          tp == SUMA_byte )   \
                                           ? 1 : 0 )

00172 {
00173    static char FuncName[]={"SUMA_2Prefix2SurfaceName"};
00174    SUMA_Boolean exist1, exist2;
00175    SUMA_SFname *SF_name1 = NULL, *SF_name2 = NULL;
00176    
00177    SUMA_ENTRY;
00178    
00179    if (!nametopo && !namecoord) { SUMA_RETURN(NULL); }
00180    
00181    if (!nametopo) SUMA_RETURN(SUMA_Prefix2SurfaceName (namecoord, path, vp_name, oType, exists));
00182    if (!namecoord) SUMA_RETURN(SUMA_Prefix2SurfaceName (nametopo, path, vp_name, oType, exists));
00183    
00184    if (strcmp(namecoord, nametopo) == 0) SUMA_RETURN(SUMA_Prefix2SurfaceName (nametopo, path, vp_name, oType, exists));
00185    if (oType != SUMA_SUREFIT && oType != SUMA_VEC) {
00186       SUMA_SL_Err("Wrong usage of function, namecoord and nametopo are different but surface type is neither SUMA_SUREFIT nor SUMA_VEC");
00187       SUMA_RETURN(NULL);
00188    }
00189    
00190    /* the pain in the behind case */
00191    SF_name1 = SUMA_Prefix2SurfaceName (namecoord, path, vp_name, oType, &exist1);
00192    if (!SF_name1) {
00193       SUMA_SL_Err("Failed to create name");
00194       SUMA_RETURN(NULL);
00195    }
00196    SF_name2 = SUMA_Prefix2SurfaceName (nametopo, path, vp_name, oType, &exist2);
00197    if (!SF_name2) {
00198       SUMA_free(SF_name1); SF_name1= NULL;
00199       SUMA_SL_Err("Failed to create name");
00200       SUMA_RETURN(NULL);
00201    }
00202    
00203    if (exist1 || exist2) *exists = YUP;
00204    
00205    sprintf(SF_name1->name_topo, "%s", SF_name2->name_topo);
00206    SUMA_free(SF_name2); SF_name2= NULL;
00207    
00208    SUMA_RETURN(SF_name1);
00209 }  

07398 {
07399    static char FuncName[]={"SUMA_Alloc_OpenDX_Struct"};
07400    int i;
07401    SUMA_OPEN_DX_STRUCT *dx = NULL;
07402    
07403    SUMA_ENTRY;
07404    
07405    dx = (SUMA_OPEN_DX_STRUCT *)SUMA_malloc(sizeof(SUMA_OPEN_DX_STRUCT));
07406    dx->rank = 0;
07407    dx->shape = 0;
07408    dx->items = 0;
07409    dx->bad_data = 0;
07410    dx->object = NULL;
07411    dx->class = NULL;
07412    dx->type = NULL;
07413    dx->data = NULL;
07414    dx->data_format = 0;
07415    dx->data_off = NULL;
07416    dx->datap = NULL;
07417    dx->n_comp = 0;
07418    dx->counts = NULL;
07419    dx->n_counts = 0;
07420    dx->origin = NULL;
07421    dx->n_origin = 0;
07422    dx->delta = NULL;
07423    dx->n_delta = 0;
07424    for (i=0; i<SUMA_MAX_OPEN_DX_FIELD_COMPONENTS; ++i) { dx->comp_name[i] = dx->comp_value[i] =NULL; }
07425    dx->n_attr = 0;
07426    for (i=0; i<SUMA_MAX_OPEN_DX_FIELD_ATTRIBUTES; ++i) { dx->attr_name[i] = dx->attr_string[i] =NULL; }
07427    SUMA_RETURN(dx);
07428 }

02507 {
02508    static char FuncName[]={"SUMA_BrainVoyager_Read"};
02509         float FileVersion, cx, cy, cz, *fbuf = NULL;
02510         int i, ii, chnk, ex, surf_type, n_neighbors, bs;
02511         char buffer[256];
02512    float fbuffer[256];
02513    FILE *fl=NULL;
02514    SUMA_Boolean LocalHead = NOPE;
02515    
02516    SUMA_ENTRY;
02517    
02518    /* check for existence */
02519         if (!SUMA_filexists(f_name)) {
02520                 fprintf(SUMA_STDERR,"Error %s: File %s does not exist or cannot be read.\n", FuncName, f_name);
02521                 SUMA_RETURN (NOPE);
02522         }else {
02523       if ( debug > 1) {
02524                    fprintf(SUMA_STDERR,"%s: File %s exists and will be read.\n", FuncName, f_name);
02525            }
02526    }
02527         
02528    fl = fopen(f_name, "r");
02529    if (!fl) {
02530       SUMA_SL_Err("Failed to open file for reading.\n");
02531       SUMA_RETURN(NOPE);
02532    }
02533    
02534    SO->N_Node=0;
02535         SO->N_FaceSet=0;
02536    
02537    /* read version, and number of nodes and facesets, assume no swapping for the moment */
02538    bs = 0;
02539    chnk = sizeof(float);
02540    ex = fread (&FileVersion, chnk, 1, fl);
02541    chnk = sizeof(int);
02542    ex = fread (&surf_type, chnk, 1, fl); /* must be 0, per website www.brainvoyager.com... */
02543    ex = fread (&(SO->N_Node), chnk, 1, fl);
02544    ex = fread (&(SO->N_FaceSet), chnk, 1, fl);
02545    if (FileVersion < 0 || FileVersion > 500000 || SO->N_Node < 0 || SO->N_FaceSet < 0) { /* trouble perhaps ? */
02546       SUMA_LH("Byte swapping needed...");
02547       bs = 1;
02548    }
02549    if (bs) {
02550       SUMA_SWAP_THIS(&FileVersion, sizeof(float));
02551       SUMA_SWAP_THIS(&surf_type, sizeof(int));
02552       SUMA_SWAP_THIS(&(SO->N_Node), sizeof(int));
02553       SUMA_SWAP_THIS(&(SO->N_FaceSet), sizeof(int));
02554    }
02555    
02556    if (LocalHead) {
02557       fprintf (SUMA_STDERR,"%s:\nSurfType is %d\nN_Node = %d, N_FaceSet = %d\n", 
02558                            FuncName, surf_type, SO->N_Node, SO->N_FaceSet);
02559    }
02560    
02561    if (FileVersion < 0 || FileVersion > 500000) { /* trouble perhaps ? */
02562       SUMA_SL_Err("Version number < 0 || > 500000 \nSeems like bad news to me, quitting...");
02563       fclose(fl);
02564       SUMA_RETURN(NOPE);
02565    }
02566    
02567    
02568    if (SO->N_Node < 0 || SO->N_FaceSet < 0) {
02569       SUMA_SL_Err("Negative values for N_Node and N_FaceSet.");
02570       fclose(fl);
02571       SUMA_RETURN(NOPE);
02572    } 
02573    
02574    SUMA_READ_FLOAT(&cx, bs, fl, ex);
02575    SUMA_READ_FLOAT(&cy, bs, fl, ex);
02576    SUMA_READ_FLOAT(&cz, bs, fl, ex);
02577    if (LocalHead) {
02578       fprintf (SUMA_STDERR,"%s:\ncenter = [%f, %f, %f]\n(Niko adds 30 to cy ...)\n", FuncName, cx, cy, cz);
02579    }
02580    SO->NodeDim = 3;
02581    SO->FaceSetDim = 3;
02582    fbuf = (float *)SUMA_malloc(SO->N_Node*sizeof(float));
02583    SO->NodeList = (float *)SUMA_malloc(SO->NodeDim*SO->N_Node*sizeof(float));
02584    SO->FaceSetList = (int *)SUMA_malloc(SO->FaceSetDim*SO->N_FaceSet*sizeof(int));
02585    if (!fbuf || !SO->NodeList || !SO->FaceSetList) {
02586       SUMA_SL_Crit("Failed to allocate.");
02587       SUMA_RETURN(NOPE);
02588    }
02589    
02590    /* read the coords */
02591    SUMA_LH("Reading coords...");
02592    ex = fread(fbuf, sizeof(float), SO->N_Node, fl);
02593    if (ex != SO->N_Node) { SUMA_SL_Warn("Failed to read all node X info"); }
02594    if (bs) SUMA_SWAP_VEC(fbuf,SO->N_Node,sizeof(float));
02595    for (i=0; i<SO->N_Node; ++i) SO->NodeList[3*i] = fbuf[i];
02596    ex = fread(fbuf, sizeof(float), SO->N_Node, fl);
02597    if (ex != SO->N_Node) { SUMA_SL_Warn("Failed to read all node Y info"); }
02598    if (bs) SUMA_SWAP_VEC(fbuf,SO->N_Node,sizeof(float));
02599    for (i=0; i<SO->N_Node; ++i) SO->NodeList[3*i+1] = fbuf[i];
02600    ex = fread(fbuf, sizeof(float), SO->N_Node, fl);
02601    if (ex != SO->N_Node) { SUMA_SL_Warn("Failed to read all node Z info"); }
02602    if (bs) SUMA_SWAP_VEC(fbuf,SO->N_Node,sizeof(float));
02603    for (i=0; i<SO->N_Node; ++i) SO->NodeList[3*i+2] = fbuf[i];
02604    SUMA_free(fbuf); fbuf = NULL;
02605    if (LocalHead) { 
02606       char *sdbg = SUMA_ShowMeSome((void *)SO->NodeList, SUMA_float, SUMA_MIN_PAIR(20, SO->N_Node), 20);
02607       fprintf(SUMA_STDERR,"%s NodeList:\n%s\n", FuncName, sdbg);
02608       SUMA_free(sdbg);sdbg = NULL;
02609    }
02610    /* skip the node normals, which would be read much like the x y z coords*/
02611    fseek(fl, SO->N_Node*3*sizeof(float), SEEK_CUR);
02612    
02613    /* skip the curvature color info */
02614    ex = fread(fbuffer, sizeof(float), 8, fl); /* colors of convex and concave stuff */
02615    if (bs) SUMA_SWAP_VEC(fbuffer,8, sizeof(float));
02616    if (LocalHead) { 
02617       char *sdbg = SUMA_ShowMeSome((void *)fbuffer, SUMA_float, 8,8);
02618       fprintf(SUMA_STDERR,"%s colorstuff:\n%s\n", FuncName, sdbg);
02619       SUMA_free(sdbg);sdbg = NULL;
02620    }
02621    fseek(fl, SO->N_Node*sizeof(float), SEEK_CUR); /* junp over mesh color */
02622    
02623    /* skip nearest neighbor info */
02624    for (i=0; i<SO->N_Node; ++i) {
02625       ex = fread(&n_neighbors, sizeof(int), 1, fl);
02626       if (bs) SUMA_SWAP_THIS(&n_neighbors, sizeof(int));
02627       fseek(fl, n_neighbors*sizeof(int), SEEK_CUR);
02628    }
02629    
02630    /* read dems triangles */
02631    SUMA_LH("Reading FaceSets...");
02632    ex = fread(SO->FaceSetList, sizeof(int), SO->N_FaceSet * SO->FaceSetDim , fl);
02633    if (ex != SO->N_FaceSet * SO->FaceSetDim) { 
02634       fprintf(SUMA_STDERR,"Error %s: Failed to read all faceset info.\nRead %d values, expected %d\n", FuncName, ex, SO->N_FaceSet * SO->FaceSetDim );
02635       SUMA_RETURN(NOPE);
02636    }
02637    
02638    if (bs) SUMA_SWAP_VEC(SO->FaceSetList,(SO->N_FaceSet * SO->FaceSetDim),sizeof(int));
02639    if (LocalHead) { 
02640       char *sdbg = SUMA_ShowMeSome((void *)SO->FaceSetList, SUMA_int, SUMA_MIN_PAIR(20, SO->N_FaceSet * SO->FaceSetDim), 20);
02641       fprintf(SUMA_STDERR,"%s FaceSetList:\n%s\n", FuncName, sdbg);
02642       SUMA_free(sdbg);sdbg = NULL;
02643    }
02644    fclose(fl); fl = NULL;
02645    
02646    SO->FileType = SUMA_BRAIN_VOYAGER;
02647    SO->Name = SUMA_StripPath(f_name);
02648    SO->FileFormat = SUMA_BINARY;    /* files are likely all BINARY_LE, must take care of that at some point*/
02649    
02650    SUMA_LH("Done.");
02651    
02652    SUMA_RETURN(YUP);
02653 }

06183 {
06184    static char FuncName[]={"SUMA_DrawnROI_to_1DDrawROI"};
06185    SUMA_1D_DRAWN_ROI *ROI_1D=NULL;
06186    SUMA_ROI_DATUM *ROI_Datum=NULL;
06187    DListElmt *Elm = NULL;
06188    int i = -1, cnt = 0, *isort=NULL, *iLabel=NULL, *iNode=NULL;
06189    SUMA_Boolean LocalHead = NOPE;
06190 
06191    SUMA_ENTRY;
06192 
06193    if (!ROI) {
06194       SUMA_SL_Err("Null ROI");
06195       SUMA_RETURN(NULL);
06196    }
06197    
06198    /* count the total number of nodes in ROI */
06199    
06200    /* allocate for nimlROI */
06201    ROI_1D = (SUMA_1D_DRAWN_ROI *)SUMA_malloc(sizeof(SUMA_1D_DRAWN_ROI));
06202    Elm = NULL;
06203    ROI_1D->N = 0;
06204    do {
06205       if (!Elm) Elm = dlist_head(ROI->ROIstrokelist); 
06206       else Elm = Elm->next;
06207       ROI_Datum = (SUMA_ROI_DATUM *)Elm->data;
06208       ROI_1D->N += ROI_Datum->N_n;
06209    } while (Elm != dlist_tail(ROI->ROIstrokelist));
06210       
06211    ROI_1D->Type = (int)ROI->Type;
06212    ROI_1D->idcode_str = ROI->idcode_str;
06213    ROI_1D->Parent_idcode_str = ROI->Parent_idcode_str;
06214    ROI_1D->Label = ROI->Label;
06215    ROI_1D->iNode = NULL;
06216    ROI_1D->iLabel = NULL;
06217    iNode = (int *) SUMA_calloc(ROI_1D->N, sizeof(int));
06218    iLabel = (int *) SUMA_calloc(ROI_1D->N, sizeof(int));
06219    if (!iNode || !iLabel) {
06220       SUMA_SL_Err("Failed to allocate");
06221       SUMA_RETURN(NULL);
06222    }
06223    
06224    /* now fill the node indices and the node values */
06225    Elm = NULL;
06226    cnt = 0;
06227    do {
06228       if (!Elm) Elm = dlist_head(ROI->ROIstrokelist);
06229       else Elm = Elm->next;
06230       ROI_Datum = (SUMA_ROI_DATUM *)Elm->data;
06231       for (i=0; i < ROI_Datum->N_n; ++i) {
06232          iNode[cnt] = ROI_Datum->nPath[i];
06233          iLabel[cnt] = ROI->iLabel;
06234          ++cnt;
06235       }
06236    } while (Elm != dlist_tail(ROI->ROIstrokelist));
06237    
06238    /* some node entries are redundant, clear those up */
06239    /* first sort iNode */
06240    isort = SUMA_z_dqsort( iNode, ROI_1D->N);
06241 
06242    /* Now sort the labels accordingly */
06243    ROI_1D->iLabel = (int *) SUMA_calloc(ROI_1D->N, sizeof(int));
06244    ROI_1D->iNode = (int *) SUMA_calloc(ROI_1D->N, sizeof(int));
06245    if (!ROI_1D->iNode || !ROI_1D->iLabel) {
06246       SUMA_SL_Err("Failed to allocate");
06247       SUMA_RETURN(NULL);
06248    }
06249    
06250    for (i=0; i < ROI_1D->N; ++i) {
06251       ROI_1D->iLabel[i] = iLabel[isort[i]];
06252    }
06253    if (iLabel) SUMA_free(iLabel); iLabel = NULL; /* done with unsorted version of iLabel */
06254    
06255    /* Now remove redundant entries */
06256    cnt = 0;
06257    ROI_1D->iNode[cnt] = iNode[0]; 
06258    ROI_1D->iLabel[cnt] = ROI_1D->iLabel[0];
06259    ++cnt;
06260    for (i=1;i<ROI_1D->N;++i)
06261     {
06262       if ((iNode[i] != iNode[i- 1]))
06263          {
06264             ROI_1D->iNode[cnt] = iNode[i];
06265             ROI_1D->iLabel[cnt] = ROI_1D->iLabel[i]; 
06266             ++cnt;   
06267          }
06268    }
06269 
06270    
06271    /* you would reallocate here, because cnt is always <= ROI_1D->N,
06272    but it is not worth the effort because cnt is only slightly
06273    less than ROI_1D->N */
06274    
06275    /* just update ROI_1D->N */
06276    ROI_1D->N = cnt;
06277    
06278    if (isort) SUMA_free(isort); isort = NULL;
06279    if (iNode) SUMA_free(iNode); iNode = NULL;
06280    
06281    SUMA_RETURN(ROI_1D);
06282 }

08131 {
08132    static char FuncName[]={"SUMA_Find_OpenDX_Object_Class"};
08133    int i;
08134    SUMA_OPEN_DX_STRUCT *dx = NULL;
08135    SUMA_Boolean LocalHead = NOPE;
08136    
08137    SUMA_ENTRY;
08138    
08139    *nf = 0;
08140    for (i=0; i<iop; ++i) {
08141       if (strstr(dxv[i]->class, nm)) { 
08142          if (!dx) dx = dxv[i]; 
08143          ++ (*nf);
08144       }
08145    }
08146    
08147    if (LocalHead) fprintf(SUMA_STDERR,"%s: Found %d objects\n", FuncName, *nf);
08148    SUMA_RETURN(dx);
08149 }

08107 {
08108    static char FuncName[]={"SUMA_Find_OpenDX_Object_Name"};
08109    int i;
08110    SUMA_OPEN_DX_STRUCT *dx = NULL;
08111    SUMA_Boolean LocalHead = NOPE;
08112    
08113    SUMA_ENTRY;
08114    
08115    *nf = 0;
08116    for (i=0; i<iop; ++i) {
08117       if (strstr(dxv[i]->object, nm)) { 
08118          if (!dx) dx = dxv[i]; 
08119          ++ (*nf);
08120       }
08121    }
08122    
08123    if (LocalHead) fprintf(SUMA_STDERR,"%s: Found %d objects\n", FuncName, *nf);
08124    SUMA_RETURN(dx);
08125 }

06470 {
06471    static char FuncName[]={"SUMA_FormAfnidset"};
06472    THD_coorder cord;
06473    int ii=0,jj=0,kk=0,ll=0,ijk=0 , nx=0,ny=0,nz=0 , nxyz=0 ;
06474    float      xx,yy,zz,vv=0.0 , dx,dy,dz;
06475    short               sv=0   ;
06476    byte                bv=0   ;
06477    float *fbr=NULL, fval_float, dval_float;
06478    byte *bbr=NULL, *mmask=NULL, fval_byte, dval_byte;
06479    short *sbr=NULL, fval_short, dval_short;
06480    char *orcode=NULL;
06481    float xxdown =0.0,xxup=0.0 , yydown=0.0,yyup=0.0 , zzdown=0.0,zzup=0.0 ;
06482    
06483    THD_3dim_dataset *dset=NULL, *mset=NULL, *maskset=NULL;
06484 
06485    /* check for badiosity */
06486    if( Opt->do_ijk == 0 && Opt->master == NULL ) {
06487       SUMA_SL_Err("Can't use mm coords without master.") ;
06488       SUMA_RETURN(NULL);
06489    }
06490    if( (Opt->master == NULL && Opt->mset == NULL) && Opt->dimen_ii < 2 ) {
06491       SUMA_SL_Err("Must use exactly one of Opt->master or Opt->dimen options");
06492       SUMA_RETURN(NULL);
06493    }
06494    if (Opt->master && Opt->mset) {
06495       SUMA_SL_Err("Cannot use Opt->master and Opt->mset");
06496       SUMA_RETURN(NULL);
06497    }
06498    
06499    fval_byte = (byte)Opt->fval;
06500    fval_short = (short)Opt->fval;
06501    fval_float = (float)Opt->fval;
06502    dval_byte = (byte)Opt->dval;
06503    dval_short = (short)Opt->dval;
06504    dval_float = (float)Opt->dval;
06505    
06506    if( (Opt->datum == MRI_short && dval_short == fval_short) ||
06507     (Opt->datum == MRI_float && dval_float == fval_float) ||
06508     (Opt->datum == MRI_byte  && dval_byte  == fval_byte )   ){
06509 
06510       SUMA_SL_Warn("dval and fval are the same!") ;
06511    }
06512 
06513    if (Opt->full_list && NodeList) {
06514       SUMA_SL_Err("Opt->full_list && NodeList");
06515       SUMA_RETURN(NULL);
06516    }
06517    if (!Opt->full_list && !NodeList &&!Opt->mmask) {
06518       SUMA_SL_Err("!Opt->full_list && !NodeList && !Opt->mmask");
06519       SUMA_RETURN(NULL);
06520    }
06521 
06522    if (!Opt->prefix || !Opt->prefix_path) {
06523       SUMA_SL_Err("Need a prefix and a prefix_path Joe.");
06524       SUMA_RETURN(NULL);
06525    }
06526 
06527    if (!NodeList && !vals && !Opt->mmask) {
06528       SUMA_SL_Warn("Creating a dataset of constants. (!NodeList && !vals && !Opt->mmask)");
06529    }
06530    
06531    if (Opt->master) {
06532       mset = THD_open_dataset(Opt->master);
06533       if( mset == NULL ) {
06534          SUMA_SL_Err("-master: can't open dataset" ) ; 
06535          SUMA_RETURN(dset);
06536       }
06537    }
06538    if (Opt->mset) mset = Opt->mset;
06539    
06540    if ((Opt->master || Opt->mset) && Opt->orcode) {
06541       SUMA_SL_Err("Cannot have bothpt->master && Opt->orcode");
06542       SUMA_RETURN(dset);      
06543    }
06544    
06545    if (Opt->mask && Opt->mmask) {
06546       SUMA_SL_Err("Cannot have both Opt->mask && Opt->mmask");
06547       SUMA_RETURN(dset);
06548    }
06549 
06550    if (Opt->mask) {
06551       maskset = THD_open_dataset( Opt->mask) ;
06552       if( maskset == NULL ) {
06553          SUMA_SL_Err("-mask: can't open dataset" ) ; 
06554          if (mset) {  DSET_delete(mset); mset = NULL; }
06555          SUMA_RETURN(dset);
06556       }
06557    }
06558    
06559    
06560   /*-- set orcode to value from -master, if this is needed --*/
06561 
06562   if( mset != NULL ){
06563       orcode = malloc(4) ;
06564       orcode[0] = ORIENT_typestr[mset->daxes->xxorient][0] ;
06565       orcode[1] = ORIENT_typestr[mset->daxes->yyorient][0] ;
06566       orcode[2] = ORIENT_typestr[mset->daxes->zzorient][0] ;
06567       orcode[3] = '\0' ;
06568    } else if (Opt->orcode) {
06569       orcode = malloc(4) ; orcode = strcpy(orcode, Opt->orcode);
06570    } else {
06571       SUMA_SL_Err("Huh?");
06572       if (mset) {  DSET_delete(mset); mset = NULL; }
06573       if (maskset) {  DSET_delete(maskset); maskset = NULL; }
06574       SUMA_RETURN(dset);
06575    }
06576 
06577    THD_coorder_fill( orcode , &cord ) ;  /* setup coordinate order */ 
06578 
06579    /*-- make empty dataset --*/
06580    if( mset != NULL ){                 /* from -master */
06581 
06582       dset = EDIT_empty_copy( mset ) ;
06583       EDIT_dset_items( dset ,
06584                           ADN_prefix    , Opt->prefix ,
06585                           ADN_datum_all , Opt->datum ,
06586                           ADN_nvals     , 1 ,
06587                           ADN_ntt       , 0 ,
06588                           ADN_func_type , ISANAT(mset) ? mset->func_type
06589                                                        : FUNC_FIM_TYPE ,
06590 
06591                           ADN_directory_name , Opt->prefix_path ,
06592                           ADN_none ) ;
06593 
06594    } else {                            /* from nothing */
06595      THD_ivec3 iv_nxyz   , iv_xyzorient ;
06596      THD_fvec3 fv_xyzorg , fv_xyzdel ;
06597 
06598      LOAD_IVEC3( iv_nxyz , Opt->dimen_ii , Opt->dimen_jj , Opt->dimen_kk ) ;
06599      LOAD_IVEC3( iv_xyzorient , cord.xxor , cord.yyor , cord.zzor ) ;
06600      LOAD_FVEC3( fv_xyzdel ,
06601                  ORIENT_sign[iv_xyzorient.ijk[0]]=='+' ? 1.0 : -1.0 ,
06602                  ORIENT_sign[iv_xyzorient.ijk[1]]=='+' ? 1.0 : -1.0 ,
06603                  ORIENT_sign[iv_xyzorient.ijk[2]]=='+' ? 1.0 : -1.0  ) ;
06604      LOAD_FVEC3( fv_xyzorg ,
06605                  ORIENT_sign[iv_xyzorient.ijk[0]]=='+' ? -0.5*Opt->dimen_ii : 0.5*Opt->dimen_ii,
06606                  ORIENT_sign[iv_xyzorient.ijk[1]]=='+' ? -0.5*Opt->dimen_jj : 0.5*Opt->dimen_jj,
06607                  ORIENT_sign[iv_xyzorient.ijk[2]]=='+' ? -0.5*Opt->dimen_kk : 0.5*Opt->dimen_kk ) ;
06608 
06609      dset = EDIT_empty_copy( NULL ) ;
06610 
06611      EDIT_dset_items( dset ,
06612                        ADN_nxyz      , iv_nxyz ,
06613                        ADN_xyzdel    , fv_xyzdel ,
06614                        ADN_xyzorg    , fv_xyzorg ,
06615                        ADN_xyzorient , iv_xyzorient ,
06616                        ADN_prefix    , Opt->prefix ,
06617                        ADN_datum_all , Opt->datum ,
06618                        ADN_nvals     , 1 ,
06619                        ADN_ntt       , 0 ,
06620                        ADN_type      , HEAD_FUNC_TYPE ,
06621                        ADN_func_type , FUNC_FIM_TYPE ,
06622                        ADN_directory_name , Opt->prefix_path ,
06623                     ADN_none ) ;
06624 
06625    }
06626 
06627    if( THD_is_file(DSET_HEADNAME(dset)) ) {
06628       SUMA_SL_Err("Output dataset already exists -- can't overwrite") ;
06629       exit(1);
06630    }
06631    /*-- make empty brick array for dataset --*/
06632 
06633    EDIT_substitute_brick( dset , 0 , Opt->datum , NULL ) ;  /* will make array */
06634 
06635    nx = DSET_NX(dset); ny = DSET_NY(dset); nz = DSET_NZ(dset); nxyz = nx*ny*nz;
06636 
06637    if (Opt->full_list && N_vals != nxyz) {
06638       SUMA_SL_Err("Opt->full_list && N_vals != nx*ny*nz");
06639       SUMA_RETURN(NULL);
06640    }
06641    /* 19 Feb 2004: check and make mask if desired */
06642 
06643    if( maskset != NULL &&
06644        ( DSET_NX(maskset) != nx ||
06645          DSET_NY(maskset) != ny ||
06646          DSET_NZ(maskset) != nz   ) ) {
06647      SUMA_SL_Err("mask dataset doesn't match dimension of output dataset") ;
06648      if (mset) {  DSET_delete(mset); mset = NULL; }
06649      if (maskset) {  DSET_delete(maskset); maskset = NULL; }
06650      SUMA_RETURN(NULL);
06651    }
06652 
06653    if( maskset != NULL ){
06654      mmask = THD_makemask( maskset , 0 , 1.0,-1.0 ) ;
06655      SUMA_SL_Warn("can't create mask for some reason!") ;
06656      DSET_delete(maskset) ;
06657    } else mmask = Opt->mmask;
06658 
06659    if( mmask == NULL ){
06660    } else {
06661       int nmask = THD_countmask( nxyz , mmask ) ;
06662       if( nmask == 0 ){
06663          SUMA_SL_Warn("0 voxels in mask -- ignoring it!") ;
06664          if (!Opt->mmask) free((void *)mmask) ; mmask = NULL ;
06665       } else {
06666          fprintf(SUMA_STDERR,"%s:++ %d voxels found in mask\n", FuncName, nmask) ;
06667       }
06668    }
06669 
06670    /*-- fill new dataset brick with the -fval value --*/
06671    switch( Opt->datum ){
06672       case MRI_short:
06673          if (0) fprintf(SUMA_STDERR,"%s: Filling with %d\n", FuncName, fval_short);
06674          sbr = (short *) DSET_BRICK_ARRAY(dset,0) ;
06675          for( ii=0 ; ii < nxyz ; ii++ ) sbr[ii] = fval_short ;
06676       break ;
06677 
06678       case MRI_float:
06679          fbr = (float *) DSET_BRICK_ARRAY(dset,0) ;
06680          for( ii=0 ; ii < nxyz ; ii++ ) fbr[ii] = fval_float ;
06681       break ;
06682 
06683       case MRI_byte:
06684          bbr = (byte *) DSET_BRICK_ARRAY(dset,0) ;
06685          for( ii=0 ; ii < nxyz ; ii++ ) bbr[ii] = fval_byte ;
06686       break ;
06687    }
06688 
06689    /* 24 Nov 2000: get the bounding box for the dataset */
06690 
06691    dx = fabs(dset->daxes->xxdel) ; if( dx <= 0.0 ) dx = 1.0 ;
06692    dy = fabs(dset->daxes->yydel) ; if( dy <= 0.0 ) dy = 1.0 ;
06693    dz = fabs(dset->daxes->zzdel) ; if( dz <= 0.0 ) dz = 1.0 ;
06694 
06695    if( !Opt->do_ijk ){
06696 #ifndef EXTEND_BBOX
06697       xxdown = dset->daxes->xxmin - 0.501 * dx ;
06698       xxup   = dset->daxes->xxmax + 0.501 * dx ;
06699       yydown = dset->daxes->yymin - 0.501 * dy ;
06700       yyup   = dset->daxes->yymax + 0.501 * dy ;
06701       zzdown = dset->daxes->zzmin - 0.501 * dz ;
06702       zzup   = dset->daxes->zzmax + 0.501 * dz ;
06703 #else
06704       xxdown = dset->daxes->xxmin ;
06705       xxup   = dset->daxes->xxmax ;
06706       yydown = dset->daxes->yymin ;
06707       yyup   = dset->daxes->yymax ;
06708       zzdown = dset->daxes->zzmin ;
06709       zzup   = dset->daxes->zzmax ;
06710 #endif
06711    }
06712 
06713    for (ll=0; ll<N_vals; ++ll) {
06714       /* stick 'em in */
06715       if (!Opt->full_list) {
06716          xx = NodeList[3*ll]; yy = NodeList[3*ll+1]; zz = NodeList[3*ll+2]; 
06717          if (Opt->do_ijk) {
06718             ii = (int) rint(xx) ; jj = (int) rint(yy) ; kk = (int) rint(zz) ;
06719             if( ii < 0 || ii >= nx ){
06720                fprintf(stderr,
06721                        "Warning %s: entry %d: i index=%d is invalid, ignoring...\n",
06722                        FuncName,ll,ii) ;
06723                continue ;
06724             }
06725             if( jj < 0 || jj >= ny ){
06726                fprintf(stderr,
06727                        "Warning %s: entry %d: j index=%d is invalid, ignoring...\n",
06728                        FuncName, ll,jj) ;
06729                continue ;
06730             }
06731             if( kk < 0 || kk >= nz ){
06732                fprintf(stderr,
06733                        "Warning %s: entry %d: k index=%d is invalid\n",
06734                        FuncName,ll,kk) ;
06735                continue ;
06736             }
06737          } else {   /* inputs are coordinates => must convert to index */
06738 
06739             THD_fvec3 mv , dv ;                              /* temp vectors */
06740             THD_ivec3 iv ;
06741 
06742             THD_coorder_to_dicom( &cord , &xx,&yy,&zz ) ;    /* to Dicom order */
06743             LOAD_FVEC3( dv , xx,yy,zz ) ;
06744             mv = THD_dicomm_to_3dmm( dset , dv ) ;           /* to Dataset order */
06745 
06746             /* 24 Nov 2000: check (xx,yy,zz) for being inside the box */
06747 
06748             if( mv.xyz[0] < xxdown || mv.xyz[0] > xxup ){
06749                fprintf(stderr,"+++ Warning %s: line %d: x coord=%g is outside %g .. %g\n" ,
06750                        FuncName,ll,mv.xyz[0] , xxdown,xxup ) ;
06751                continue ;
06752             }
06753             if( mv.xyz[1] < yydown || mv.xyz[1] > yyup ){
06754                fprintf(stderr,"+++ Warning %s: line %d: y coord=%g is outside %g .. %g\n" ,
06755                        FuncName,ll,mv.xyz[1] , yydown , yyup ) ;
06756                continue ;
06757             }
06758             if( mv.xyz[2] < zzdown || mv.xyz[2] > zzup ){
06759                fprintf(stderr,"+++ Warning %s: line %d: z coord=%g is outside %g .. %g\n" ,
06760                        FuncName,ll,mv.xyz[2] , zzdown , zzup ) ;
06761                continue ;
06762             }
06763 
06764             iv = THD_3dmm_to_3dind( dset , mv ) ;            /* to Dataset index */
06765             ii = iv.ijk[0]; jj = iv.ijk[1]; kk = iv.ijk[2];  /* save */
06766          }
06767 
06768          ijk = ii + jj*nx + kk*nx*ny ;
06769       } else {
06770          ijk = ll; 
06771       }
06772 
06773       if (vals) vv = vals[ll];
06774       else vv = dval_float ;   
06775 
06776       if( mmask == NULL || mmask[ijk] ){
06777          switch( Opt->datum ){
06778             case MRI_float:{
06779               if( fbr[ijk] != fval_float && fbr[ijk] != vv )
06780                 fprintf(stderr,"Overwrite voxel %d %d %d\n",ii,jj,kk) ;
06781               fbr[ijk] = vv ;
06782             }
06783             break ;
06784             case MRI_short:{
06785               sv = SHORTIZE(vv) ;
06786               if( sbr[ijk] != fval_short && sbr[ijk] != sv )
06787                 fprintf(stderr,"Overwrite voxel %d %d %d\n",ii,jj,kk) ;
06788               sbr[ijk] = sv ;
06789             }
06790             break ;
06791             case MRI_byte:{
06792               bv = BYTEIZE(vv) ;
06793               if( bbr[ijk] != fval_byte && bbr[ijk] != bv )
06794                 fprintf(stderr,"Overwrite voxel %d %d %d\n",ii,jj,kk) ;
06795               bbr[ijk] = bv ;
06796             }
06797             break ;
06798          }
06799       }
06800 
06801    }
06802    
06803    if (orcode) free(orcode); orcode = NULL;
06804    if (mmask && !Opt->mmask) free(mmask); mmask = NULL;
06805    if (mset && !Opt->mset) DSET_delete(mset); mset = NULL; 
06806 
06807    SUMA_RETURN(dset);      
06808 }

06291 {
06292    static char FuncName[]={"SUMA_Free_1DDrawROI"};
06293    SUMA_Boolean LocalHead = NOPE;
06294    
06295    SUMA_ENTRY;
06296 
06297    if (!ROI_1D) SUMA_RETURN(NULL);
06298    
06299    if (ROI_1D->iLabel) SUMA_free(ROI_1D->iLabel); 
06300    if (ROI_1D->iNode) SUMA_free(ROI_1D->iNode);
06301    
06302    SUMA_free(ROI_1D);
06303    
06304    SUMA_RETURN(NULL);
06305 }

06409 {
06410    static char FuncName[]={"SUMA_Free_FormAfniDset_Opt"};
06411    SUMA_ENTRY;
06412    
06413    if (!Opt) SUMA_RETURN(NULL);
06414    
06415    if (Opt->master) SUMA_free(Opt->master);
06416    if (Opt->mask) SUMA_free(Opt->mask);  
06417    if (Opt->mset) {
06418       SUMA_SL_Warn("mset is not freed in this function.\nMake sure it is not a lost pointer.\nSet mset to NULL to avoid seeing this message");
06419    } 
06420    if (Opt->prefix) SUMA_free(Opt->prefix);
06421    if (Opt->prefix_path) SUMA_free(Opt->prefix_path);
06422    if (Opt->mmask) SUMA_free(Opt->mmask);
06423    if (Opt->orcode) SUMA_free(Opt->orcode);
06424    SUMA_free(Opt);
06425    
06426    SUMA_RETURN(NULL);
06427 }

02410 {
02411         static char FuncName[]={"SUMA_Free_FreeSurfer"};
02412    
02413    SUMA_ENTRY;
02414 
02415         if (FS->FaceSetList != NULL) SUMA_free(FS->FaceSetList);
02416         if (FS->NodeList != NULL) SUMA_free(FS->NodeList);
02417         if (FS->NodeId != NULL) SUMA_free(FS->NodeId);
02418         if (FS->FaceSetIndexInParent != NULL) SUMA_free(FS->FaceSetIndexInParent);
02419         if (FS != NULL) SUMA_free(FS);
02420         SUMA_RETURN (YUP);
02421 }

07446 {
07447    static char FuncName[]={"SUMA_Free_OpenDX_Struct"};
07448    int i;
07449    
07450    SUMA_ENTRY;
07451    
07452    if (!dx) SUMA_RETURN(dx);
07453    if (dx->object) SUMA_free(dx->object); dx->object = NULL;
07454    if (dx->class) SUMA_free(dx->class); dx->class = NULL;
07455    if (dx->data) SUMA_free(dx->data); dx->data = NULL;
07456    if (dx->data_off) SUMA_free(dx->data_off); dx->data_off = NULL;
07457    if (dx->datap) {
07458       if ( SUMA_OK_OPENDX_DATA_TYPE(SUMA_VarType2TypeCast (dx->type)) ) {
07459          SUMA_free(dx->datap); dx->datap = NULL;
07460       } else {
07461          SUMA_SL_Warn("Do not know how to free datap.\nYou now possibly have a leak on your hands.");
07462       }
07463    }
07464    if (dx->type) SUMA_free(dx->type); dx->type = NULL;
07465    for (i=0; i<SUMA_MAX_OPEN_DX_FIELD_COMPONENTS; ++i) { 
07466       if (dx->comp_name[i]) SUMA_free(dx->comp_name[i]); dx->comp_name[i] = NULL;
07467       if (dx->comp_value[i]) SUMA_free(dx->comp_value[i]); dx->comp_value[i] =NULL; 
07468    }
07469    for (i=0; i<SUMA_MAX_OPEN_DX_FIELD_ATTRIBUTES; ++i) { 
07470       if (dx->attr_name[i]) SUMA_free(dx->attr_name[i]); dx->attr_name[i] = NULL;
07471       if (dx->attr_string[i]) SUMA_free(dx->attr_string[i]); dx->attr_string[i] =NULL; 
07472    }
07473    if (dx->origin) SUMA_free(dx->origin); 
07474    if (dx->delta) SUMA_free(dx->delta);
07475    if (dx->counts) SUMA_free(dx->counts);
07476    SUMA_free(dx); dx = NULL;
07477    SUMA_RETURN(dx);
07478 }

07431 {
07432    static char FuncName[]={"SUMA_Free_OpenDX_StructVec"};
07433    int i;
07434    
07435    SUMA_ENTRY;
07436    
07437    if (!dxv) SUMA_RETURN(NULL);
07438    for (i=0; i<nobj; ++i) {
07439       dxv[i] = SUMA_Free_OpenDX_Struct(dxv[i]);
07440    }
07441    SUMA_free(dxv); 
07442    SUMA_RETURN(NULL);
07443 }

00819 {
00820         static char FuncName[]={"SUMA_Free_SureFit"};
00821         
00822         SUMA_ENTRY;
00823 
00824         if (SF->NodeList != NULL) SUMA_free(SF->NodeList);
00825         if (SF->NodeId != NULL) SUMA_free(SF->NodeId);
00826         if (SF->Specs_mat != NULL) SUMA_free2D ((char **)SF->Specs_mat, SF->N_Node_Specs);
00827         if (SF->FN.FirstNeighb != NULL) SUMA_free2D((char **)SF->FN.FirstNeighb, SF->FN.N_Node);
00828         if (SF->FN.N_Neighb != NULL) SUMA_free(SF->FN.N_Neighb);
00829         if (SF->FN.NodeId != NULL) SUMA_free(SF->FN.NodeId);
00830         if (SF->FaceSetList != NULL) SUMA_free(SF->FaceSetList);
00831         if (SF!= NULL) SUMA_free(SF);
00832         
00833         SUMA_RETURN (YUP);
00834 }

01909 {/* SUMA_FreeSurfer_Read */
01910    static char FuncName[]={"SUMA_FreeSurfer_Read"};
01911 
01912    SUMA_ENTRY;
01913 
01914    SUMA_RETURN(SUMA_FreeSurfer_Read_eng(f_name, FS, 1));
01915 }/* SUMA_FreeSurfer_Read */

01955 {/*SUMA_FreeSurfer_Read_eng*/
01956         static char FuncName[]={"SUMA_FreeSurfer_Read_eng"};
01957    char stmp[50]; 
01958    FILE *fs_file;
01959         int ex, cnt, jnki, amax[3], maxamax, maxamax2, id, ND, id2, NP, ip, *NodeId;
01960         float jnkf, *NodeList;
01961         char c;
01962         SUMA_Boolean LocalHead = NOPE;
01963            
01964         SUMA_ENTRY;
01965 
01966         /* check for existence */
01967         if (!SUMA_filexists(f_name)) {
01968                 fprintf(SUMA_STDERR,"Error %s: File %s does not exist or cannot be read.\n", FuncName, f_name);
01969                 SUMA_RETURN (NOPE);
01970         }else if ( debug > 1) {
01971                 fprintf(SUMA_STDERR,"%s: File %s exists and will be read.\n", FuncName, f_name);
01972         }
01973         
01974         
01975         /* start reading */
01976         fs_file = fopen (f_name,"r");
01977         if (fs_file == NULL)
01978                 {
01979                         SUMA_error_message (FuncName,"Could not open input file ",0);
01980                         SUMA_RETURN (NOPE);
01981                 }
01982 
01983         sprintf(FS->name, "%s", f_name);
01984         
01985         /* read first character and check if it is a comment */
01986         ex = fscanf (fs_file,"%c",&c);
01987         if (c == '#') {
01988                 if (LocalHead) fprintf (SUMA_STDOUT, "%s: Found comment\n", FuncName); 
01989                 
01990       /*skip till next line */
01991                 sprintf(FS->comment,"#"); 
01992                 cnt = 0;
01993                 while (ex != EOF && c != '\n') {
01994                         ex = fscanf (fs_file,"%c",&c);
01995                         if (cnt < SUMA_MAX_STRING_LENGTH-2) {
01996                                 sprintf(FS->comment, "%s%c", FS->comment, c);
01997                                 ++cnt;
01998                         } else {
01999                                 fprintf(SUMA_STDERR,"Error %s: Too long a comment in FS file, increase SUMA_FS_MAX_COMMENT_LENGTH\n", FuncName);
02000                                 SUMA_RETURN (NOPE);
02001                         }
02002                 }
02003         }
02004         
02005         /* find out if surface is patch */
02006         sprintf(stmp,"patch");
02007         if (SUMA_iswordin (FS->comment, stmp) == 1) {
02008                 FS->isPatch = YUP;
02009         }
02010         else {
02011                 FS->isPatch = NOPE;
02012         }
02013                 
02014         /* read in the number of nodes and the number of facesets */
02015         ex = fscanf(fs_file, "%d %d", &(FS->N_Node), &(FS->N_FaceSet));
02016         
02017    if (FS->N_Node <= 0 || FS->N_FaceSet <= 0) {
02018       SUMA_SL_Crit("Trouble parsing FreeSurfer file.\nNull or negative number of nodes &/| facesets.\n");
02019       SUMA_RETURN(NOPE);
02020    }
02021    
02022         if (LocalHead) fprintf (SUMA_STDOUT, "%s: Allocating for NodeList (%dx3) and FaceSetList(%dx3)\n", FuncName, FS->N_Node, FS->N_FaceSet);
02023    
02024    /* allocate space for NodeList and FaceSetList */
02025         FS->NodeList = (float *)SUMA_calloc(FS->N_Node * 3, sizeof(float));
02026         FS->FaceSetList = (int *)SUMA_calloc(FS->N_FaceSet * 3, sizeof(int));
02027         FS->NodeId = (int *)SUMA_calloc(FS->N_Node, sizeof(int));
02028         if (FS->NodeList == NULL || FS->FaceSetList == NULL || FS->NodeId == NULL) {
02029                 fprintf(SUMA_STDERR,"Error %s: Could not allocate for FS->NodeList &/| FS->FaceSetList &/| FS->NodeId\n", FuncName);
02030                 SUMA_RETURN (NOPE);
02031         } 
02032         if (FS->isPatch) {
02033                 FS->FaceSetIndexInParent = (int *)SUMA_calloc(FS->N_FaceSet, sizeof(int));
02034                 if (FS->FaceSetIndexInParent == NULL) {
02035                         fprintf(SUMA_STDERR,"Error %s: Could not allocate for FS->FaceSetIndexInParent\n", FuncName);
02036                         SUMA_RETURN (NOPE);
02037                 }
02038         } else {
02039                 FS->FaceSetIndexInParent = NULL;
02040         }
02041         
02042         if (!FS->isPatch) {
02043            if (LocalHead) fprintf (SUMA_STDOUT, "%s: Reading full surface...\n", FuncName);
02044                 /* read in the nodes */
02045                 cnt = 0;
02046                 while (ex != EOF && cnt < FS->N_Node) {
02047                         FS->NodeId[cnt] = cnt;
02048                         id = 3 * cnt;
02049                         ex = fscanf(fs_file, "%f %f %f %f", &(FS->NodeList[id]), &(FS->NodeList[id+1]),&(FS->NodeList[id+2]), &jnkf);
02050                         ++cnt;
02051                 }
02052                 if (cnt != FS->N_Node) {
02053                         fprintf(SUMA_STDERR,"Error %s: Expected %d nodes, %d read.\n", FuncName, FS->N_Node, cnt);
02054                         SUMA_RETURN (NOPE);
02055                 }
02056 
02057                 /* read in the facesets */
02058                 cnt = 0;
02059                 while (ex != EOF && cnt < FS->N_FaceSet) {
02060                         ip = 3 * cnt;
02061                         ex = fscanf(fs_file, "%d %d %d %d", &(FS->FaceSetList[ip]), &(FS->FaceSetList[ip+1]),&(FS->FaceSetList[ip+2]), &jnki);
02062                         ++cnt;
02063                 }
02064                 if (cnt != FS->N_FaceSet) {
02065                         fprintf(SUMA_STDERR,"Error %s: Expected %d FaceSets, %d read.\n", FuncName, FS->N_FaceSet, cnt);
02066                         SUMA_RETURN (NOPE);
02067                 }
02068         } /* read a full surface */
02069         else { /* that's a patch */
02070            #if 0 /* old way, simple parsing ... */
02071          if (LocalHead) fprintf (SUMA_STDOUT, "%s: Reading patch olde way...\n", FuncName);
02072                    /* Node IDs are a reference to those in the parent surface */
02073                    cnt = 0;
02074          while (ex != EOF && cnt < FS->N_Node) {
02075                            ex = fscanf(fs_file, "%d", &(FS->NodeId[cnt]));
02076                            id = 3 * cnt;
02077             /* fprintf (SUMA_STDERR, "FS->NodeId[cnt] = %d: cnt = %d, id=%d, id1 = %d, id2 = %d\n", FS->NodeId[cnt], cnt, id, id+1, id+2); */ 
02078                            ex = fscanf(fs_file, "%f %f %f", &(FS->NodeList[id]),&(FS->NodeList[id+1]),&(FS->NodeList[id+2]));
02079                            ++cnt;
02080                    }
02081          if (cnt != FS->N_Node) {
02082                            fprintf(SUMA_STDERR,"Error %s: Expected %d nodes, %d read.\n", FuncName, FS->N_Node, cnt);
02083                            SUMA_RETURN (NOPE);
02084                    }
02085 
02086          if (LocalHead) fprintf (SUMA_STDOUT, "%s: Reading FaceSets...\n", FuncName);
02087                    /* read in the facesets */
02088                    cnt = 0;
02089                    while (ex != EOF && cnt < FS->N_FaceSet) {
02090                            ex = fscanf(fs_file, "%d", &(FS->FaceSetIndexInParent[cnt]));
02091                            ip = 3 * cnt;
02092                            ex = fscanf(fs_file, "%d %d %d",  &(FS->FaceSetList[ip]), &(FS->FaceSetList[ip+1]),&(FS->FaceSetList[ip+2]));
02093                            ++cnt;
02094                    }
02095                    if (cnt != FS->N_FaceSet) {
02096                            fprintf(SUMA_STDERR,"Error %s: Expected %d FaceSets, %d read.\n", FuncName, FS->N_FaceSet, cnt);
02097                            SUMA_RETURN (NOPE);
02098                    }
02099       #else 
02100       {
02101          char *fl=NULL, *eop=NULL, *florig=NULL;
02102          int ans, pnodes, ptri, Found, nchar;
02103          double dbuf;
02104          
02105          if (LocalHead) fprintf (SUMA_STDOUT, "%s: Reading patch new way...\n", FuncName);
02106          /* suck in the bastard, perhaps this should be done from the start, maybe in the future */  
02107          fl = florig = SUMA_file_suck(f_name, &nchar);
02108          if (!nchar || !fl) { 
02109             SUMA_SL_Err("Failed to read patch file.");
02110             SUMA_RETURN(NOPE);
02111          }
02112          /* skip comment, if any */
02113          SUMA_IS_COMMENT_LINE(fl, NULL, '#', ans);
02114          if (ans) {  
02115             SUMA_LH("Skipping comment..."); 
02116             SUMA_SKIP_LINE(fl, NULL);
02117          }else {
02118             SUMA_SL_Err("Expected comment line....");
02119          }
02120          /* read in first two nums */
02121          SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); pnodes = (int)dbuf;
02122          SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); ptri = (int)dbuf;
02123          
02124          /* Node IDs are a reference to those in the parent surface */
02125                    Found = 1;
02126          cnt = 0;
02127          while (Found && cnt < FS->N_Node) {
02128                            eop = fl+50; /* don't you dare use (fl+50) instead of eop below!, else you will serch till the end all the time!
02129                            Macro Danger! */
02130             SUMA_ADVANCE_PAST(fl, eop,"vno=",Found,0);  /* The new patch format ... */
02131             SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); FS->NodeId[cnt] = (int)dbuf;
02132                            id = 3 * cnt;
02133             /* fprintf (SUMA_STDERR, "FS->NodeId[cnt] = %d: cnt = %d, id=%d, id1 = %d, id2 = %d\n", FS->NodeId[cnt], cnt, id, id+1, id+2); */ 
02134                            SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); FS->NodeList[id] = (float)dbuf;
02135             SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); FS->NodeList[id+1] = (float)dbuf;
02136             SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); FS->NodeList[id+2] = (float)dbuf;
02137                            ++cnt;
02138                    }
02139          if (cnt != FS->N_Node) {
02140                            fprintf(SUMA_STDERR,"Error %s: Expected %d nodes, %d read.\n", FuncName, FS->N_Node, cnt);
02141                            SUMA_RETURN (NOPE);
02142                    }
02143          if (LocalHead) fprintf (SUMA_STDOUT, "%s: Reading FaceSets...\n", FuncName);
02144                    /* read in the facesets */
02145                    Found = 1;
02146                    cnt = 0;
02147          while (Found && cnt < FS->N_FaceSet) {
02148                            SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); FS->FaceSetIndexInParent[cnt] = (int)dbuf;
02149                            ip = 3 * cnt;
02150                            SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); FS->FaceSetList[ip  ] = (int)dbuf;
02151                            SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); FS->FaceSetList[ip+1] = (int)dbuf;
02152                            SUMA_ADVANCE_PAST_NUM(fl, dbuf, Found); FS->FaceSetList[ip+2] = (int)dbuf;
02153                            ++cnt;
02154                    }
02155                    if (cnt != FS->N_FaceSet) {
02156                            fprintf(SUMA_STDERR,"Error %s: Expected %d FaceSets, %d read.\n", FuncName, FS->N_FaceSet, cnt);
02157                            SUMA_RETURN (NOPE);
02158                    }
02159          SUMA_free(florig); fl = florig = NULL; /*  */
02160       }   
02161       #endif   
02162       
02163                 /* The FaceSet List which will be read next, uses indices into the NodeList of the parent surface
02164                 This means that it expects a NodeList of the size of the NodeList in the parent surface. 
02165                 One could read the maximum number of nodes in the parent surface and create a NodeList of that size.
02166                 However, that would require keeping track of the link between the patch file and the parent file.
02167                 Instead, I will search through the FaceSetList for the highest index and allocate a new nodelist to match it*/
02168       
02169                 SUMA_MAX_VEC(FS->FaceSetList, FS->N_FaceSet * 3, maxamax); ++maxamax;
02170       /* make sure that the node list does not refer to nodes of an index higher than that in NodeId */
02171       SUMA_MAX_VEC(FS->NodeId, FS->N_Node, maxamax2); ++maxamax2;
02172       if (maxamax2 > maxamax) {
02173          fprintf(SUMA_STDERR,"Error %s: Found NodeId in the NodeList larger than Ids found in FaceSetList.\n", FuncName);
02174          SUMA_RETURN (NOPE);
02175       }
02176       if (LocalHead) fprintf (SUMA_STDOUT, "%s: Copying NodeList, allocating for new nodelist %dx3 elements...\n", \
02177          FuncName, maxamax);
02178          
02179                 NodeList = (float *)SUMA_calloc(maxamax * 3, sizeof(float));
02180                 NodeId = (int *)SUMA_calloc (maxamax, sizeof(int));
02181       
02182       if (NodeList == NULL || NodeId == NULL)
02183                 {
02184                         fprintf(SUMA_STDERR,"Error %s: Could not allocate for NodeList or NodeId\n", FuncName);
02185                         SUMA_RETURN (NOPE);
02186                 } 
02187                 /*Now copy pertinent nodes into NodeList */
02188                 
02189       for (cnt=0; cnt< FS->N_Node; ++cnt) {
02190                         id = 3*cnt; 
02191                         id2 = 3*FS->NodeId[cnt];
02192          /* fprintf (SUMA_STDERR, "%s: id = %d id2 = %d\n", FuncName, id, id2); */
02193                         NodeList[id2] = FS->NodeList[id];
02194                         NodeList[id2+1] = FS->NodeList[id+1];
02195                         NodeList[id2+2] = FS->NodeList[id+2];
02196                 }
02197                 
02198       /* this is redundant here, but should be done to match what comes out of a full surface */
02199       for (cnt=0; cnt< maxamax; ++cnt) {
02200          NodeId[cnt] = cnt;
02201       }
02202       
02203       /* Now free FS->NodeList & FS->NodeId */
02204                 SUMA_free(FS->NodeList);
02205                 SUMA_free(FS->NodeId);
02206       
02207                 /*make FS->NodeList be NodeList */
02208                 FS->NodeList = NodeList;
02209       FS->NodeId = NodeId;
02210                 FS->N_Node = maxamax;
02211         } /* read a patch */
02212         
02213         fclose (fs_file);
02214         SUMA_RETURN (YUP);
02215         
02216 }/* SUMA_FreeSurfer_Read_eng*/

02287 {/*SUMA_FreeSurfer_ReadBin_eng*/
02288         static char FuncName[]={"SUMA_FreeSurfer_ReadBin_eng"};
02289    char stmp[50]; 
02290    FILE *fs_file;
02291         int ex, End, rmax,  chnk, cnt, i, amax[3], maxamax, maxamax2, id, ND, id2, NP, ip, *NodeId, magic;
02292         float jnkf, *NodeList;
02293         char c;
02294    byte m1, m2, m3;
02295         SUMA_Boolean bs;
02296    SUMA_Boolean LocalHead = NOPE;
02297            
02298         SUMA_ENTRY;
02299    
02300    if (debug) LocalHead = YUP;
02301    
02302         /* check for existence */
02303         if (!SUMA_filexists(f_name)) {
02304                 fprintf(SUMA_STDERR,"Error %s: File %s does not exist or cannot be read.\n", FuncName, f_name);
02305                 SUMA_RETURN (NOPE);
02306         }else if ( debug > 1) {
02307                 fprintf(SUMA_STDERR,"%s: File %s exists and will be read.\n", FuncName, f_name);
02308         }
02309         
02310         /* start reading */
02311         fs_file = fopen (f_name,"r");
02312         if (fs_file == NULL)
02313                 {
02314                         SUMA_SL_Err ("Could not open input file ");
02315                         SUMA_RETURN (NOPE);
02316                 }
02317 
02318    SUMA_WHAT_ENDIAN(End);
02319    if (End == MSB_FIRST) {
02320       SUMA_LH("No swapping needed");
02321       bs = NOPE;
02322    } else {
02323       bs = YUP;
02324       SUMA_LH("Swapping needed");
02325    }
02326    
02327    ex = fread (&m1, 1, 1, fs_file);
02328    ex = fread (&m2, 1, 1, fs_file);
02329    ex = fread (&m3, 1, 1, fs_file);
02330    magic = (m1 << 16) + (m2 << 8) + m3 ;
02331    if (magic == (-2 & 0x00ffffff)) {
02332       SUMA_LH("OK tri");
02333    } else {
02334       SUMA_SL_Err("Failed to identify magic number for a triangulated surface.\n");
02335       SUMA_RETURN(NOPE);
02336    }
02337    chnk = sizeof(char);
02338    ex = fread (&c, chnk, 1, fs_file);
02339    rmax = 0;
02340    while (c != '\n' &&rmax < 5000) {
02341       if (LocalHead) fprintf(SUMA_STDERR,"%c",c);
02342       ex = fread (&c, chnk, 1, fs_file);
02343       ++rmax;
02344    }
02345    if (rmax >= 5000) {
02346       SUMA_SL_Err("Unexpected tres tres long comment.");
02347       SUMA_RETURN(NOPE);
02348    }
02349    SUMA_LH("End of comment");
02350    /* read one more to skip second \n */
02351    ex = fread (&c, chnk, 1, fs_file);
02352    if (c != '\n') {
02353       SUMA_SL_Err("Failed to find second newline.");
02354       SUMA_RETURN(NOPE);
02355    }else {
02356       SUMA_LH("Found end of comment");
02357    }
02358    
02359    /* read the number of nodes and the number of triangles */
02360    SUMA_READ_INT (&FS->N_Node, bs, fs_file, ex);
02361    if (FS->N_Node < 0 || FS->N_Node > 2000000) {
02362       SUMA_SL_Err("Failed to get number of nodes");
02363       SUMA_RETURN(NOPE);
02364    }else {
02365       if (LocalHead) fprintf(SUMA_STDERR,"%s: Expecting to read %d nodes.\n", FuncName, FS->N_Node);
02366    }
02367    
02368    SUMA_READ_INT (&FS->N_FaceSet, bs, fs_file, ex);
02369    if (FS->N_FaceSet < 0 || FS->N_FaceSet > 2000000) {
02370       SUMA_SL_Err("Failed to get number of triangles");
02371       SUMA_RETURN(NOPE);
02372    }else {
02373       if (LocalHead) fprintf(SUMA_STDERR,"%s: Expecting to read %d triangles.\n", FuncName, FS->N_FaceSet);
02374    }
02375    
02376    /* allocate */
02377         FS->NodeList = (float *)SUMA_calloc(FS->N_Node * 3, sizeof(float));
02378         FS->FaceSetList = (int *)SUMA_calloc(FS->N_FaceSet * 3, sizeof(int));
02379    if (!FS->NodeList || !FS->FaceSetList) {
02380       SUMA_SL_Err("Failed to allocate");
02381       SUMA_RETURN(NOPE);
02382    }
02383    
02384    /*read in the meat */
02385    for (i=0; i<FS->N_Node * 3; ++i) {
02386       SUMA_READ_FLOAT (&(FS->NodeList[i]), bs, fs_file, ex);
02387       if (ex == EOF) {
02388          SUMA_SL_Err("Premature end of file!");
02389          SUMA_free(FS->NodeList); SUMA_free(FS->FaceSetList);  FS->NodeList = NULL ; FS->FaceSetList = NULL;
02390          SUMA_RETURN(NOPE);
02391       }
02392    }
02393    for (i=0; i<FS->N_FaceSet * 3; ++i) {
02394       SUMA_READ_INT (&(FS->FaceSetList[i]), bs, fs_file, ex);
02395       if (ex == EOF) {
02396          SUMA_SL_Err("Premature end of file!");
02397          SUMA_free(FS->NodeList); SUMA_free(FS->FaceSetList);  FS->NodeList = NULL ; FS->FaceSetList = NULL;
02398          SUMA_RETURN(NOPE);
02399       }   
02400    }
02401    
02402    fclose(fs_file);
02403    SUMA_LH("Returning");
02404    SUMA_RETURN(YUP);
02405 }

02219 {
02220    static char FuncName[]={"SUMA_FreeSurfer_WritePatch"};
02221    int cnt, i, iface;
02222    int *FaceSetIndexInParent=NULL;
02223    SUMA_Boolean *isInPatch=NULL;
02224    FILE *fout=NULL;
02225    
02226    SUMA_ENTRY;
02227    
02228    if (!fileNm || !SO || !SO_parent || !SO_parent->EL) {
02229       SUMA_SL_Err("NULL input params");
02230       SUMA_RETURN(NOPE);
02231    }
02232    
02233    if (SUMA_filexists(fileNm)) {
02234       SUMA_SL_Err("Output file exists, will not overwrite");
02235       SUMA_RETURN(NOPE);
02236    }
02237    
02238    fout = fopen(fileNm,"w");
02239    if (!fout) {
02240       SUMA_SL_Err("Failed to open file for writing.\nCheck permissions.");
02241       SUMA_RETURN(NOPE);
02242    }
02243    
02244    if (firstLine) {
02245       fprintf(fout, "%s\n", firstLine);
02246    } else {
02247       if (!SO->Label) SO->Label = SUMA_SurfaceFileName (SO, NOPE);
02248       fprintf(fout, "#!ascii version of patch %s\n", SO->Label);
02249    }
02250    
02251    /* which nodes are in this patch ? */
02252    isInPatch = SUMA_MaskOfNodesInPatch(SO, &cnt);
02253    if (!isInPatch) {
02254       SUMA_SL_Crit("Failed in SUMA_MaskOfNodesInPatch");
02255       SUMA_RETURN(NOPE);
02256    }
02257 
02258    /* number of nodes and number of triangles in mesh */
02259    fprintf(fout, "%d %d\n", cnt, SO->N_FaceSet);
02260    /* write the node coordinates */
02261    for (i=0; i < SO->N_Node; ++i) {
02262       if (isInPatch[i]) {
02263          fprintf(fout, "%d\n%f\t%f\t%f\n", i, SO->NodeList[3*i], SO->NodeList[3*i+1], SO->NodeList[3*i+2]);
02264       }
02265    }
02266    for (i=0; i < SO->N_FaceSet; ++i) {
02267       iface = SUMA_whichTri (SO_parent->EL, SO->FaceSetList[3*i], SO->FaceSetList[3*i+1], SO->FaceSetList[3*i+2], 0);
02268       if (iface < 0) {
02269          SUMA_SL_Warn("Parent surface does not contain triangle in patch!\nTriangle skipped.");
02270       } else {
02271          fprintf(fout, "%d\n%d\t%d\t%d\n", iface, SO->FaceSetList[3*i], SO->FaceSetList[3*i+1], SO->FaceSetList[3*i+2]);
02272       }
02273    }
02274    
02275    
02276    SUMA_free(FaceSetIndexInParent); FaceSetIndexInParent = NULL;
02277    SUMA_free(isInPatch); isInPatch = NULL;
02278 
02279    fclose(fout);
02280    SUMA_RETURN(YUP);
02281 }

03167 {
03168    static char FuncName[]={"SUMA_FS_Write"};
03169    int i, j;
03170    FILE *outFile = NULL;
03171    
03172    SUMA_ENTRY;
03173    
03174    if (SUMA_filexists(fileNm)) {
03175       fprintf (SUMA_STDERR, "Error %s: file %s exists, will not overwrite.\n",FuncName, fileNm);
03176       SUMA_RETURN (NOPE);
03177    }
03178    
03179    if (SO->NodeDim != 3 || SO->FaceSetDim != 3) {
03180       fprintf (SUMA_STDERR, "Error %s: Must have NodeDim and FaceSetDim = 3.\n",FuncName);
03181       SUMA_RETURN (NOPE);
03182    }
03183 
03184    outFile = fopen(fileNm, "w");
03185    if (!outFile) {
03186       fprintf (SUMA_STDERR, "Error %s: Failed in opening %s for writing.\n",FuncName, fileNm);
03187       SUMA_RETURN (NOPE);
03188    } 
03189    
03190    fprintf (outFile,"#%s\n", firstLine);
03191    fprintf (outFile, "%d %d\n", SO->N_Node, SO->N_FaceSet);
03192 
03193    j=0;
03194    for (i=0; i<SO->N_Node; ++i) {
03195       j=SO->NodeDim * i;
03196       fprintf (outFile, "%f  %f  %f  0\n", SO->NodeList[j], SO->NodeList[j+1], SO->NodeList[j+2]);
03197    }
03198 
03199    j=0;
03200    for (i=0; i<SO->N_FaceSet; ++i) {
03201       j = SO->FaceSetDim * i;
03202       fprintf (outFile, "%d %d %d 0\n", SO->FaceSetList[j], SO->FaceSetList[j+1], SO->FaceSetList[j+2]);
03203    }
03204     
03205    
03206    fclose(outFile);
03207 
03208    SUMA_RETURN (YUP);
03209    
03210 }

00052 {
00053    static char FuncName[]={"SUMA_Load_Surface_Object_Wrapper"};
00054    SUMA_SurfaceObject *SO=NULL;
00055    void *SO_name=NULL;
00056    SUMA_SFname *SF_name = NULL;
00057    SUMA_Boolean LocalHead = NOPE;
00058 
00059    SUMA_ENTRY;
00060 
00061    switch (SO_FT) {
00062       case SUMA_SUREFIT:
00063          SF_name = (SUMA_SFname *) SUMA_malloc(sizeof(SUMA_SFname));
00064          sprintf(SF_name->name_coord,"%s", if_name);
00065          sprintf(SF_name->name_topo,"%s", if_name2); 
00066          if (!vp_name) { /* initialize to empty string */
00067             SF_name->name_param[0] = '\0'; 
00068          }
00069          else {
00070             sprintf(SF_name->name_param,"%s", vp_name);
00071          }
00072          SO_name = (void *)SF_name;
00073          if (debug > 0) fprintf (SUMA_STDOUT,"Reading %s and %s...\n", SF_name->name_coord, SF_name->name_topo);
00074          SO = SUMA_Load_Surface_Object (SO_name, SUMA_SUREFIT, SUMA_ASCII, sv_name);
00075          break;
00076       case SUMA_VEC:
00077          SF_name = (SUMA_SFname *) SUMA_malloc(sizeof(SUMA_SFname));
00078          sprintf(SF_name->name_coord,"%s", if_name);
00079          sprintf(SF_name->name_topo,"%s", if_name2); 
00080          SO_name = (void *)SF_name;
00081          fprintf (SUMA_STDOUT,"Reading %s and %s...\n", SF_name->name_coord, SF_name->name_topo);
00082          SO = SUMA_Load_Surface_Object (SO_name, SUMA_VEC, SUMA_ASCII, sv_name);
00083          break;
00084       case SUMA_FREE_SURFER:
00085       case SUMA_FREE_SURFER_PATCH:
00086          SO_name = (void *)if_name; 
00087          fprintf (SUMA_STDOUT,"Reading %s ...\n",if_name);
00088          if (SUMA_isExtension(SO_name, ".asc")) 
00089             SO = SUMA_Load_Surface_Object (SO_name, SUMA_FREE_SURFER, SUMA_ASCII, sv_name);
00090          else
00091             SO = SUMA_Load_Surface_Object_eng (SO_name, SUMA_FREE_SURFER, SUMA_BINARY_BE, sv_name, 0);
00092          break;  
00093       case SUMA_OPENDX_MESH:
00094          SO_name = (void *)if_name; 
00095          fprintf (SUMA_STDOUT,"Reading %s ...\n",if_name);
00096          SO = SUMA_Load_Surface_Object (SO_name, SUMA_OPENDX_MESH, SUMA_ASCII, sv_name);
00097          break;  
00098       case SUMA_PLY:
00099          SO_name = (void *)if_name; 
00100          fprintf (SUMA_STDOUT,"Reading %s ...\n",if_name);
00101          SO = SUMA_Load_Surface_Object (SO_name, SUMA_PLY, SUMA_FF_NOT_SPECIFIED, sv_name);
00102          break;  
00103       case SUMA_BRAIN_VOYAGER:
00104          SO_name = (void *)if_name; 
00105          fprintf (SUMA_STDOUT,"Reading %s ...\n",if_name);
00106          SO = SUMA_Load_Surface_Object (SO_name, SUMA_BRAIN_VOYAGER, SUMA_BINARY, sv_name);
00107          break;  
00108       default:
00109          fprintf (SUMA_STDERR,"Error %s: Bad format.\n", FuncName);
00110          exit(1);
00111    }
00112 
00113    if (SF_name) SUMA_free(SF_name); SF_name = NULL;
00114    SUMA_RETURN(SO);
00115 }

06381 {
06382    static char FuncName[]={"SUMA_New_FormAfniDset_Opt"};
06383    SUMA_FORM_AFNI_DSET_STRUCT *Opt=NULL;
06384    
06385    SUMA_ENTRY;
06386    
06387    Opt = (SUMA_FORM_AFNI_DSET_STRUCT*)SUMA_malloc(sizeof(SUMA_FORM_AFNI_DSET_STRUCT));
06388    
06389    Opt->master = NULL;
06390    Opt->mset = NULL;
06391    Opt->mask = NULL;
06392    Opt->prefix = NULL;
06393    Opt->prefix_path = NULL;
06394    Opt->orcode = NULL;
06395    Opt->do_ijk = 1;
06396    Opt->dimen_ii=0;
06397    Opt->dimen_jj=0;
06398    Opt->dimen_kk=0;
06399    Opt->datum=MRI_short;
06400    Opt->dval=1.0;
06401    Opt->fval=0.0;
06402    Opt->mmask=NULL;
06403    Opt->full_list = 0;
06404    
06405    SUMA_RETURN(Opt);
06406 }

07140 {
07141    static char FuncName[]={"SUMA_nimlSO2SO"};
07142    NI_element *nel = NULL;
07143    char stmp[500], *tmp;
07144    int ip;
07145    SUMA_SurfaceObject *SO=NULL;
07146    SUMA_Boolean LocalHead = NOPE;
07147    
07148    SUMA_ENTRY;
07149    
07150    if (!ngr) {  SUMA_SL_Err("Null ngr"); SUMA_RETURN(SO); }
07151    
07152    if (strcmp(ngr->name, "SurfaceObject")) {
07153       fprintf (SUMA_STDERR,"Error %s: group name (%s) is not (SUMA_SurfaceObject)\nObject does not appear to be a surface.", FuncName, ngr->name);
07154    }
07155    
07156    /* a new surface */
07157    SO = SUMA_Alloc_SurfObject_Struct(1); 
07158    if (!SO) { SUMA_SL_Err("Failed to create SO."); SUMA_RETURN(SO); }
07159    
07160    /** BEGIN ATTRIBUTES COMMON TO ALL OBJECTS **/ 
07161    tmp = SUMA_copy_string(NI_get_attribute(ngr,"Object_ID"));
07162    if (SUMA_IS_EMPTY_STR_ATTR(tmp)) { 
07163       SUMA_SL_Warn("No ID in nel.\nThat's not cool yall.\n I'll be adding a new one now."); SUMA_NEW_ID(SO->idcode_str, NULL); 
07164       NI_set_attribute(ngr, "Group_ID", SO->idcode_str);
07165    } else SO->idcode_str = SUMA_copy_string(tmp);
07166    
07167    tmp = NI_get_attribute(ngr, "Object_Type");
07168    if (SUMA_IS_EMPTY_STR_ATTR(tmp)) { SUMA_SL_Err("Missing Object Type."); SUMA_Free_Surface_Object(SO); SO = NULL; SUMA_RETURN(SO); }
07169    if (!strcmp(tmp, "Triangulated_Surface")) SO->FaceSetDim = 3;
07170    else {
07171       fprintf (SUMA_STDERR,"Error %s: Object_Type %s not recognized.\n", FuncName, tmp);
07172       SUMA_Free_Surface_Object(SO); SO = NULL; SUMA_RETURN(SO); 
07173    }   
07174    
07175    tmp = NI_get_attribute(ngr, "Object_Label");
07176    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->Label = SUMA_copy_string(tmp);  
07177    
07178    /* set the parent ID */
07179    tmp = NI_get_attribute(ngr, "Parent_ID");
07180    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->LocalDomainParentID = SUMA_copy_string(tmp);  
07181    
07182    
07183    /* set the grand parent ID */
07184    tmp = NI_get_attribute(ngr, "Grand_Parent_ID");
07185    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->DomainGrandParentID = SUMA_copy_string(tmp);  
07186    
07187    
07188    /** END ATTRIBUTES COMMON TO ALL OBJECTS **/      
07189    
07190    /** BEGIN ATTRIBUTES specific to Surfaces**/
07191    tmp = NI_get_attribute(ngr, "Subject_ID");
07192    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->Group_idcode_str = SUMA_copy_string(tmp); 
07193    
07194    tmp = NI_get_attribute(ngr, "Subject_Label");
07195    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->Group = SUMA_copy_string(tmp); 
07196    
07197    tmp = NI_get_attribute(ngr, "Instance_ID");
07198    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->OriginatorID = SUMA_copy_string(tmp);    
07199    
07200    tmp = NI_get_attribute(ngr, "Instance_Label");
07201    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->OriginatorLabel = SUMA_copy_string(tmp); 
07202    
07203    tmp = NI_get_attribute(ngr, "Model_Name");
07204    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->ModelName = SUMA_copy_string(tmp); 
07205    
07206    tmp = NI_get_attribute(ngr, "Side");
07207    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) {
07208       if (!strcmp(tmp,"none")) SO->Side = SUMA_NO_SIDE;
07209       else if (!strcmp(tmp,"left")) SO->Side = SUMA_LEFT;
07210       else if (!strcmp(tmp,"right")) SO->Side = SUMA_RIGHT;
07211    } 
07212 
07213    tmp = NI_get_attribute(ngr, "Layer_Name");
07214    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->State = SUMA_copy_string(tmp); 
07215 
07216    tmp = NI_get_attribute(ngr, "Anatomically_Correct");
07217    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) {
07218       if (!strcmp(tmp,"yes")) SO->AnatCorrect = 1; 
07219       else SO->AnatCorrect = 0; 
07220    }
07221     
07222    tmp = NI_get_attribute(ngr, "Embedding_Dimension");
07223    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->EmbedDim = atoi(tmp); 
07224    
07225    tmp = NI_get_attribute(ngr, "Surface_Creation_Software");
07226    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->FileType = SUMA_SurfaceTypeCode(tmp); 
07227    
07228    tmp = NI_get_attribute(ngr, "Standard_Space");
07229    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->StandardSpace = SUMA_copy_string(tmp); 
07230    
07231    tmp = NI_get_attribute(ngr, "SUMA_Afni_Parent_Vol_ID");
07232    if (!SUMA_IS_EMPTY_STR_ATTR(tmp)) SO->parent_vol_idcode_str = SUMA_copy_string(tmp); 
07233       
07234    
07235    /** END ATTRIBUTES specific to Surfaces**/ 
07236    
07237    /* now read the elements in this group */
07238    for( ip=0 ; ip < ngr->part_num ; ip++ ){ /* do not free elements as you process them, free with group at end */
07239       switch( ngr->part_typ[ip] ){
07240          /*-- a sub-group ==> recursion! --*/
07241          case NI_GROUP_TYPE:
07242             SUMA_SL_Err("Not ready from groups inside surface group. Group ignored"); 
07243             break ;
07244          case NI_ELEMENT_TYPE:
07245             nel = (NI_element *)ngr->part[ip] ;
07246             if (LocalHead)  {
07247                fprintf(SUMA_STDERR,"%s:     name=%s vec_len=%d vec_filled=%d, vec_num=%d\n", FuncName,\
07248                         nel->name, nel->vec_len, nel->vec_filled, nel->vec_num );
07249             }
07250 
07251             /*--- NodeList ---*/
07252             if( strcmp(nel->name,"Node_XYZ") == 0 || strcmp(nel->name,"NewNode_XYZ") == 0) { /* Get Da NodeList */
07253                if (LocalHead) fprintf (SUMA_STDERR,"%s:\nGetting NodeList...\n", 
07254                                              FuncName);
07255                if (!SUMA_NodeXYZ_nel2NodeXYZ(SO, nel)) {
07256                   SUMA_SL_Err("Failed in SUMA_NodeXYZ_nel2NodeXYZ");
07257                   SUMA_Free_Surface_Object(SO); SO = NULL; SUMA_RETURN(SO);
07258                }
07259             } else if ( strcmp(nel->name,"Mesh_IJK") == 0 || strcmp(nel->name,"NewMesh_IJK") == 0) { /* Get Da FaceSetList */ 
07260                if (LocalHead) fprintf (SUMA_STDERR,"%s:\nGetting FaceSetList...\n", 
07261                                              FuncName);
07262                if (!SUMA_Mesh_IJK_nel2Mesh_IJK(SO, nel)) {
07263                   SUMA_SL_Err("Failed in SUMA_Mesh_IJK_nel2Mesh_IJK");
07264                   SUMA_Free_Surface_Object(SO); SO = NULL; SUMA_RETURN(SO);
07265                }
07266             } else if ( strcmp(nel->name,"SurfaceVolumeParent") == 0) { /* Get Da FaceSetList */ 
07267                if (LocalHead) fprintf (SUMA_STDERR,"%s:\nGetting VolPar...\n", 
07268                                              FuncName);
07269                if (!SUMA_VolPar_nel2SOVolPar(SO, nel)) {
07270                   SUMA_SL_Err("Failed in SUMA_VolPar_nel2SOVolPar");
07271                   SUMA_Free_Surface_Object(SO); SO = NULL; SUMA_RETURN(SO);
07272                }
07273             } else {
07274                fprintf (SUMA_STDERR,"Warning %s:\n nel (%s) unknown, ignoring it.\n", FuncName, nel->name);
07275             }
07276             break;
07277          default:
07278             SUMA_SL_Err("Don't know what to make of this group element, ignoring.");
07279             break;
07280       }
07281    }
07282    
07283    if (!SO->NodeList || !SO->FaceSetList) { /* perhaps you'll remove this condition in the future ...*/
07284       SUMA_SL_Err("Looks like NodeList and/or FaceSetList not in group. Balking.\n");
07285       SUMA_Free_Surface_Object(SO); SO = NULL; SUMA_RETURN(SO);
07286    }
07287    
07288    /* check on all elements that need to be loaded */   
07289    tmp = NI_get_attribute(ngr, "Mesh_Element_ID");
07290    if (!SUMA_IS_EMPTY_STR_ATTR(tmp))  { 
07291       if (!SO->FaceSetList) { /* element was not part of this group, usually recover from other files on disk, for the moment, warning */
07292          fprintf (SUMA_STDERR,"Warning %s:\n group %s called for FaceSetList element_ID %s which was not found.\n", FuncName, ngr->name, tmp);  
07293          /* 
07294          in the future, try to load from separate file
07295          nel = SUMA_Find_nel_File(tmp); (for example) SUMA_Mesh_IJK_nel2Mesh_IJK(SO, nel) ;  NI_free_nel(nel); nel = NULL; 
07296          */     
07297       }
07298    }
07299 
07300    tmp = NI_get_attribute(ngr, "NodeList_Element_ID");
07301    if (!SUMA_IS_EMPTY_STR_ATTR(tmp))  { 
07302       if (!SO->NodeList) { /* element was not part of this group, usually recover from other files on disk, for the moment, warning */
07303          fprintf (SUMA_STDERR,"Warning %s:\n group %s called for NodeList element_ID %s which was not found.\n", FuncName, ngr->name, tmp);  
07304          /* 
07305          in the future, try to load from separate file
07306          nel = SUMA_Find_nel_File(tmp); (for example) SUMA_NodeXYZ_nel2NodeXYZ(SO, nel) ;  NI_free_nel(nel); nel = NULL; 
07307          */     
07308       }
07309    }
07310    
07311    tmp = NI_get_attribute(ngr, "facenormals_idcode_str");
07312    if (!SUMA_IS_EMPTY_STR_ATTR(tmp))  { 
07313       if (!SO->FaceNormList) { /* element was not part of this group, usually recover from other files on disk, for the moment, warning */
07314          fprintf (SUMA_STDERR,"Warning %s:\n group %s called for facenormals element_ID %s which was not found.\n", FuncName, ngr->name, tmp);  
07315          /* 
07316          in the future, try to load from separate file
07317          nel = SUMA_Find_nel_File(tmp); (for example) xxxxxx(SO, nel) ;  NI_free_nel(nel); nel = NULL; 
07318          */     
07319       }
07320    }
07321      
07322    tmp = NI_get_attribute(ngr, "Node_Normals_Element_ID");
07323    if (!SUMA_IS_EMPTY_STR_ATTR(tmp))  { 
07324       if (!SO->NodeNormList) { /* element was not part of this group, usually recover from other files on disk, for the moment, warning */
07325          fprintf (SUMA_STDERR,"Warning %s:\n group %s called for Node_Normals element_ID %s which was not found.\n", FuncName, ngr->name, tmp);  
07326          /* 
07327          in the future, try to load from separate file
07328          nel = SUMA_Find_nel_File(tmp); (for example) xxxxxx(SO, nel) ;  NI_free_nel(nel); nel = NULL; 
07329          */     
07330       }
07331    }
07332    
07333    tmp = NI_get_attribute(ngr, "Polygon_Area_Element_ID");
07334    if (!SUMA_IS_EMPTY_STR_ATTR(tmp))  { 
07335       if (!SO->PolyArea) { /* element was not part of this group, usually recover from other files on disk, for the moment, warning */
07336          fprintf (SUMA_STDERR,"Warning %s:\n group %s called for Polygon_Area element_ID %s which was not found.\n", FuncName, ngr->name, tmp);  
07337          /* 
07338          in the future, try to load from separate file
07339          nel = SUMA_Find_nel_File(tmp); (for example) xxxxxx(SO, nel) ;  NI_free_nel(nel); nel = NULL; 
07340          */     
07341       }
07342    }
07343    
07344    tmp = NI_get_attribute(ngr, "SUMA_Edge_List_Element_ID");
07345    if (!SUMA_IS_EMPTY_STR_ATTR(tmp))  { 
07346       if (!SO->EL) { /* element was not part of this group, usually recover from other files on disk, for the moment, warning */
07347          fprintf (SUMA_STDERR,"Warning %s:\n group %s called for Edge_List element_ID %s which was not found.\n", FuncName, ngr->name, tmp);  
07348          /* 
07349          in the future, try to load from separate file
07350          nel = SUMA_Find_nel_File(tmp); (for example) xxxxxx(SO, nel) ;  NI_free_nel(nel); nel = NULL; 
07351          */     
07352       }
07353    }
07354 
07355    tmp = NI_get_attribute(ngr, "SUMA_Node_Face_Member_Element_ID");
07356    if (!SUMA_IS_EMPTY_STR_ATTR(tmp))  { 
07357       if (!SO->MF) { /* element was not part of this group, usually recover from other files on disk, for the moment, warning */
07358          fprintf (SUMA_STDERR,"Warning %s:\n group %s called for Node_Face_Member element_ID %s which was not found.\n", FuncName, ngr->name, tmp);  
07359          /* 
07360          in the future, try to load from separate file
07361          nel = SUMA_Find_nel_File(tmp); (for example) xxxxxx(SO, nel) ;  NI_free_nel(nel); nel = NULL; 
07362          */     
07363       }
07364    }
07365    
07366    tmp = NI_get_attribute(ngr, "SUMA_Node_First_Neighb_Element_ID");
07367    if (!SUMA_IS_EMPTY_STR_ATTR(tmp))  { 
07368       if (!SO->FN) { /* element was not part of this group, usually recover from other files on disk, for the moment, warning */
07369          fprintf (SUMA_STDERR,"Warning %s:\n group %s called for Node_First_Neighb element_ID %s which was not found.\n", FuncName, ngr->name, tmp);  
07370          /* 
07371          in the future, try to load from separate file
07372          nel = SUMA_Find_nel_File(tmp); (for example) xxxxxx(SO, nel) ;  NI_free_nel(nel); nel = NULL; 
07373          */     
07374       }
07375    }
07376    
07377    
07378    if (SO->MF && SO->MF->idcode_str) {
07379       NI_set_attribute(ngr, "SUMA_Node_Face_Member_Element_ID", SO->MF->idcode_str);
07380    } else {
07381       NI_set_attribute(ngr, "SUMA_Node_Face_Member_Element_ID", SUMA_EMPTY_ATTR);
07382    }
07383    
07384    if (SO->FN && SO->FN->idcode_str) {
07385       NI_set_attribute(ngr, "SUMA_Node_First_Neighb_Element_ID", SO->FN->idcode_str);
07386    } else {
07387       NI_set_attribute(ngr, "SUMA_Node_First_Neighb_Element_ID", SUMA_EMPTY_ATTR);
07388    }
07389    
07390 
07391     
07392    SUMA_RETURN(SO);
07393 }

04361 {
04362    static char FuncName[]={"SUMA_OpenDrawnROI"};
04363    DList *list=NULL;
04364    SUMA_DRAWN_ROI **ROIv=NULL;
04365    int i, N_ROI;
04366    SUMA_SurfaceObject *SO=NULL;
04367    
04368    SUMA_Boolean LocalHead = NOPE;
04369    
04370    SUMA_ENTRY;
04371 
04372    SUMA_LH("Called");   
04373 
04374    /* check for type ... */
04375    
04376    if (SUMA_isExtension(filename, ".niml.roi")) {
04377       /* load niml ROI */
04378       if (!( ROIv = SUMA_OpenDrawnROI_NIML (filename, &N_ROI, YUP))) {
04379          SUMA_SLP_Err("Failed to read NIML ROI.");
04380          SUMA_RETURNe;
04381       }
04382    }else if (SUMA_isExtension(filename, ".1D.roi")) {
04383       /* load 1D ROI */
04384       /* You need to select a parent surface */
04385       SUMA_SLP_Warn("Assuming parent surface.");
04386       SO = (SUMA_SurfaceObject *)(SUMAg_DOv[SUMAg_SVv[0].Focus_SO_ID].OP);
04387       if (!( ROIv = SUMA_OpenDrawnROI_1D (filename, SO->idcode_str, &N_ROI, YUP))) {
04388          SUMA_SLP_Err("Failed to read NIML ROI.");
04389          SUMA_RETURNe;
04390       }
04391    }else {
04392       SUMA_SLP_Err(  "Failed to recognize\n"
04393                      "ROI type from filename.");
04394       SUMA_RETURNe;
04395    } 
04396    
04397    /* put those ROIs in SUMAg_DOv */
04398    for (i=0; i < N_ROI; ++i) {
04399       /* add ROI to DO list */
04400       if (!SUMA_AddDO (SUMAg_DOv, &SUMAg_N_DOv, (void *)ROIv[i], ROIdO_type, SUMA_LOCAL)) {
04401          fprintf(SUMA_STDERR,"Error %s: Failed in SUMA_AddDO.\n", FuncName);
04402       }
04403    }
04404    /* free ROIv */
04405    if (ROIv) SUMA_free(ROIv); ROIv = NULL;
04406 
04407    /* if there are no currentROIs selected, set currentROI to the
04408       first in the list */
04409    if (!SUMAg_CF->X->DrawROI->curDrawnROI) {
04410       i = 0;
04411       do {
04412          if (SUMAg_DOv[i].ObjectType == ROIdO_type) SUMAg_CF->X->DrawROI->curDrawnROI =
04413                                              (SUMA_DRAWN_ROI *)SUMAg_DOv[i].OP;
04414          ++i;
04415       } while (i < SUMAg_N_DOv && !SUMAg_CF->X->DrawROI->curDrawnROI);
04416    }
04417    
04418    if (SUMAg_CF->X->DrawROI->curDrawnROI) {
04419       SUMA_InitializeDrawROIWindow(SUMAg_CF->X->DrawROI->curDrawnROI);   
04420    }
04421    
04422    /* Now update the Paint job on the ROI plane */
04423    if (!SUMA_Paint_SO_ROIplanes_w (
04424             SUMA_findSOp_inDOv(SUMAg_CF->X->DrawROI->curDrawnROI->Parent_idcode_str, 
04425             SUMAg_DOv, SUMAg_N_DOv), SUMAg_DOv, SUMAg_N_DOv)) {
04426       SUMA_SLP_Err("Failed in SUMA_Paint_SO_ROIplanes_w.");
04427       SUMA_RETURNe;
04428    }
04429    
04430    /* put a nice redisplay here */
04431    if (!list) list = SUMA_CreateList ();
04432    SUMA_REGISTER_TAIL_COMMAND_NO_DATA(list, SE_Redisplay_AllVisible, SES_Suma, NULL); 
04433    if (!SUMA_Engine(&list)) {
04434       SUMA_SLP_Err("Failed to redisplay.");
04435       SUMA_RETURNe;
04436    }
04437    
04438    SUMA_RETURNe; 
04439 }

04483 {
04484    static char FuncName[]={"SUMA_OpenDrawnROI_1D"};
04485    MRI_IMAGE *im = NULL;
04486    int ncol, nrow, *iLabel=NULL, *iNode = NULL, *isort=NULL,
04487       i, N_Labels = 0, *iStart=NULL, *iStop=NULL, cnt = 0;
04488    float *far=NULL, *r=NULL, *g=NULL, *b=NULL, *RGB=NULL;
04489    SUMA_DRAWN_ROI **ROIv=NULL;
04490    SUMA_Boolean LocalHead = NOPE;
04491    
04492    SUMA_ENTRY;
04493 
04494    SUMA_LH("Called");
04495    
04496    *N_ROI = 0;
04497    
04498    im = mri_read_1D (filename);
04499    
04500    if (!im) {
04501       SUMA_SLP_Err("Failed to read 1D file");
04502       SUMA_RETURN(NULL);
04503    }
04504    
04505    far = MRI_FLOAT_PTR(im);
04506    ncol = im->nx;
04507    nrow = im->ny;
04508    
04509    if (!ncol) {
04510       SUMA_SL_Err("Empty file");
04511       SUMA_RETURN(NULL);
04512    }
04513    if (nrow != 1 && nrow != 2 && nrow != 4 && nrow != 5) {
04514       SUMA_SL_Err("File must have\n"
04515                   " 1,2,4 or 5 columns.");
04516       mri_free(im); im = NULL;   /* done with that baby */
04517       SUMA_RETURN(NULL);
04518    }
04519    
04520    if (0 && LocalHead) {
04521       SUMA_disp_vect(far, ncol*nrow);
04522    }
04523       
04524    switch (nrow) {
04525       case 1:
04526          /* Node index only*/
04527          SUMA_LH ("1D format: i");
04528          iNode = (int *)SUMA_malloc(ncol*sizeof(int));
04529          iLabel = (int *)SUMA_malloc(1*sizeof(int));
04530          if (!iNode ||!iLabel) {
04531             SUMA_SL_Err("Failed to allocate");
04532             SUMA_RETURN(NULL);
04533          }
04534          for (i=0; i < ncol; ++i) iNode[i] = (int)far[i];
04535          mri_free(im); im = NULL;   /* done with that baby */
04536          
04537          iLabel[0] = 0;
04538          N_Labels = 1;
04539          iStart = (int *)SUMA_malloc(1*sizeof(int));
04540          iStop = (int *)SUMA_malloc(1*sizeof(int));
04541          RGB = (float *)SUMA_malloc(3*1*sizeof(float));
04542          iStart[0] = 0;
04543          iStop[0] = ncol-1;
04544          RGB[0] = 1.0; RGB[1] = 1.0; RGB[2] = 0;
04545          break;
04546       case 2:
04547          /* Node index & Node Label */
04548          SUMA_LH("1D format: i l");
04549          /* copy the node indices and labels for cleanliness */
04550          iLabel = (int *)SUMA_malloc(ncol*sizeof(int));
04551          iNode = (int *)SUMA_malloc(ncol*sizeof(int));
04552          if (!iNode || !iLabel) {
04553             SUMA_SL_Err("Failed to allocate");
04554             SUMA_RETURN(NULL);
04555          }
04556          for (i=0; i < ncol; ++i) iLabel[i] = (int)far[i+ncol];
04557          /* sort the Labels and the iNode accordingly */
04558          isort = SUMA_z_dqsort( iLabel, ncol);
04559          for (i=0; i < ncol; ++i) iNode[i] = (int)far[isort[i]];
04560 
04561          mri_free(im); im = NULL;   /* done with that baby */
04562 
04563          /* Count the number of distinct labels */
04564          N_Labels = 1;
04565          for (i=1; i < ncol; ++i) if (iLabel[i] != iLabel[i-1]) ++N_Labels;
04566          /* store where each label begins and ends */
04567          iStart = (int *)SUMA_malloc(N_Labels*sizeof(int));
04568          iStop = (int *)SUMA_malloc(N_Labels*sizeof(int));
04569          RGB = (float *)SUMA_malloc(3*N_Labels*sizeof(float));
04570          if (!iStart || !iStop) {
04571             SUMA_SL_Err("Failed to allocate");
04572             SUMA_RETURN(NULL);
04573          }
04574          cnt = 0;
04575          iStart[cnt] = 0;
04576          iStop[cnt] = ncol -1;
04577          RGB[3*cnt] = 1.0; RGB[3*cnt+1] = 1.0; RGB[3*cnt+2] = 0;
04578          for (i=1; i < ncol; ++i) {
04579             if (iLabel[i] != iLabel[i-1]) {
04580                iStop[cnt] = i-1;
04581                ++cnt; 
04582                iStart[cnt] = i;
04583                iStop[cnt] = ncol -1;
04584                RGB[3*cnt] = 1.0; RGB[3*cnt+1] = 1.0; RGB[3*cnt+2] = 0;
04585             }
04586          }
04587          break;
04588       case 4:
04589          /* Node index, R G B */
04590          SUMA_LH("1D format: i R G B");
04591          iNode = (int *)SUMA_malloc(ncol*sizeof(int));
04592          iLabel = (int *)SUMA_malloc(1*sizeof(int));
04593          r = (float *)SUMA_malloc(ncol*sizeof(float));
04594          g = (float *)SUMA_malloc(ncol*sizeof(float));
04595          b = (float *)SUMA_malloc(ncol*sizeof(float));
04596          if (!iNode || !iLabel || !r || !g || !b) {
04597             SUMA_SL_Err("Failed to allocate");
04598             SUMA_RETURN(NULL);
04599          }
04600          
04601          for (i=0; i < ncol; ++i) {
04602             iNode[i] = (int)far[i];
04603             r[i] = (float)far[i+ncol];
04604             g[i] = (float)far[i+2*ncol];
04605             b[i] = (float)far[i+3*ncol];
04606          }
04607          
04608          iLabel[0] = 0;
04609          N_Labels = 1;
04610          iStart = (int *)SUMA_malloc(1*sizeof(int));
04611          iStop = (int *)SUMA_malloc(1*sizeof(int));
04612          RGB = (float *)SUMA_malloc(3*1*sizeof(float));
04613          mri_free(im); im = NULL;   /* done with that baby */
04614         
04615          iStart[0] = 0;
04616          iStop[0] = ncol-1;
04617          RGB[0] = r[0]; RGB[1] = g[0]; RGB[2] = b[0];
04618          break;
04619       case 5:
04620          /* Node index, Node Label, R G B */
04621          SUMA_LH("1D format: i l R G B");
04622          /* copy the node indices and labels for cleanliness */
04623          iLabel = (int *)SUMA_malloc(ncol*sizeof(int));
04624          iNode = (int *)SUMA_malloc(ncol*sizeof(int));
04625          r = (float *)SUMA_malloc(ncol*sizeof(float));
04626          g = (float *)SUMA_malloc(ncol*sizeof(float));
04627          b = (float *)SUMA_malloc(ncol*sizeof(float));
04628          if (!iNode || !iLabel || !r || !g || !b) {
04629             SUMA_SL_Err("Failed to allocate");
04630             SUMA_RETURN(NULL);
04631          }
04632          for (i=0; i < ncol; ++i) iLabel[i] = (int)far[i+ncol];
04633          /* sort the Labels and the iNode accordingly */
04634          isort = SUMA_z_dqsort( iLabel, ncol);
04635          for (i=0; i < ncol; ++i) {
04636             iNode[i] = (int)far[isort[i]];
04637             r[i] = (float)far[isort[i]+2*ncol];
04638             g[i] = (float)far[isort[i]+3*ncol];
04639             b[i] = (float)far[isort[i]+4*ncol];
04640          }     
04641          mri_free(im); im = NULL;   /* done with that baby */
04642 
04643          /* Count the number of distinct labels */
04644          N_Labels = 1;
04645          for (i=1; i < ncol; ++i) if (iLabel[i] != iLabel[i-1]) ++N_Labels;
04646          /* store where each label begins and ends */
04647          iStart = (int *)SUMA_malloc(N_Labels*sizeof(int));
04648          iStop = (int *)SUMA_malloc(N_Labels*sizeof(int));
04649          RGB = (float *)SUMA_malloc(3*N_Labels*sizeof(float));
04650          if (!iStart || !iStop || !RGB) {
04651             SUMA_SL_Err("Failed to allocate");
04652             SUMA_RETURN(NULL);
04653          }
04654          cnt = 0;
04655          iStart[cnt] = 0;
04656          iStop[cnt] = ncol -1;
04657          RGB[3*cnt] = r[0]; RGB[3*cnt+1] = g[0]; RGB[3*cnt+2] = b[0];
04658          for (i=1; i < ncol; ++i) {
04659             if (iLabel[i] != iLabel[i-1]) {
04660                iStop[cnt] = i-1;
04661                ++cnt; 
04662                iStart[cnt] = i;
04663                iStop[cnt] = ncol -1;
04664                RGB[3*cnt] = r[i]; RGB[3*cnt+1] = g[i]; RGB[3*cnt+2] = b[i];
04665             }
04666          }
04667          break;
04668       default:
04669          SUMA_SLP_Err("Unrecognized 1D format");
04670          mri_free(im); im = NULL;   /* done with that baby */
04671          break;
04672    }
04673    
04674    
04675    ROIv = (SUMA_DRAWN_ROI **)SUMA_malloc(N_Labels*sizeof(SUMA_DRAWN_ROI*));
04676    
04677    for (i=0; i < N_Labels; ++i) {
04678       int Value, N_Node, *Node=NULL;
04679       float fillcolor[3], edgecolor[3];
04680       int edgethickness;
04681       char stmp[20], *Label=NULL;
04682       SUMA_PARSED_NAME *NewName=NULL; 
04683       
04684       edgethickness = 3;
04685       fillcolor[0] = RGB[3*i]; fillcolor[1] = RGB[3*i+1]; fillcolor[2] = RGB[3*i+2]; 
04686       edgecolor[0] = 0; edgecolor[1] = 0; edgecolor[2] = 1; 
04687       Value = iLabel[iStart[i]]; /* the index label of this ROI */
04688       N_Node = iStop[i] - iStart[i] + 1; /* Number of Nodes in this ROI */
04689       Node = &(iNode[iStart[i]]); /* pointer to location of first index in this ROI */
04690       /* prepare a label for these ROIs */
04691       NewName = SUMA_ParseFname (filename);
04692       if (!NewName) {
04693          Label = SUMA_copy_string("BadLabel");
04694       }else {
04695          sprintf(stmp,"(%d)", Value);
04696          Label = SUMA_append_string(stmp,NewName->FileName_NoExt);
04697       }
04698       SUMA_LH("Transforming to Drawn ROIs...");
04699       ROIv[i] = SUMA_1DROI_to_DrawnROI( Node, N_Node , 
04700                                     Value, Parent_idcode_str,
04701                                     Label, NULL,
04702                                     fillcolor, edgecolor, edgethickness, 
04703                                     SUMAg_DOv, SUMAg_N_DOv,
04704                                     ForDisplay);
04705       if (nrow == 5 || nrow == 4) {
04706          SUMA_LH("Marking as color by fillcolor");
04707          ROIv[i]->ColorByLabel = NOPE;
04708       }
04709       if (Label) SUMA_free(Label); Label = NULL;
04710       if (NewName) SUMA_Free_Parsed_Name(NewName); NewName = NULL;
04711       if (LocalHead) fprintf (SUMA_STDERR, "%s: ROI->Parent_idcode_str %s\n", FuncName, ROIv[i]->Parent_idcode_str);
04712 
04713    }
04714  
04715    SUMA_LH("Freeing...");
04716    
04717    if (iLabel) SUMA_free(iLabel); iLabel = NULL;
04718    if (isort) SUMA_free(isort); isort = NULL;
04719    if (iNode) SUMA_free(iNode); iNode = NULL;
04720    if (iStart) SUMA_free(iStart); iStart = NULL;
04721    if (iStop) SUMA_free(iStop); iStop = NULL;
04722    if (r) SUMA_free(r); r = NULL;
04723    if (g) SUMA_free(g); g = NULL;
04724    if (b) SUMA_free(b); b = NULL;
04725    if (RGB) SUMA_free(RGB); RGB = NULL;
04726    
04727    *N_ROI = N_Labels;
04728    SUMA_RETURN(ROIv);
04729      
04730 }

04740 { /* begin embedded function */
04741    static char FuncName[]={"SUMA_OpenDrawnROI_NIML"};
04742    char stmp[SUMA_MAX_NAME_LENGTH+100], *nel_idcode;
04743    NI_element *nel = NULL;
04744    NI_element **nelv=NULL;
04745    NI_stream ns ;
04746    int n_read=0, idat, answer, inel, iDO, N_nel;
04747    SUMA_NIML_ROI_DATUM *niml_ROI_datum_buff=NULL;
04748    SUMA_NIML_DRAWN_ROI * nimlROI=NULL;
04749    SUMA_DRAWN_ROI **ROIv=NULL;
04750    SUMA_Boolean found = YUP, AddNel = YUP, AlwaysReplace = NOPE, NeverReplace = NOPE;
04751    SUMA_Boolean LocalHead = NOPE;
04752    
04753    SUMA_ENTRY;
04754 
04755    *N_ROI = 0;
04756    
04757    if (SUMAg_CF->nimlROI_Datum_type < 0) {
04758       SUMA_SL_Err("Bad niml type code");
04759       SUMA_RETURN(NULL);
04760    }
04761    if (LocalHead) fprintf(SUMA_STDERR, "%s: roi_type code = %d\n", FuncName, SUMAg_CF->nimlROI_Datum_type) ;
04762 
04763    sprintf(stmp,"file:%s", filename);
04764    ns = NI_stream_open( stmp , "r" ) ;
04765    if( ns == NULL ){
04766       SUMA_SL_Err("Can't open ROI file"); 
04767       SUMA_RETURN(NULL);
04768    }
04769    
04770    nelv = (NI_element **) SUMA_calloc(SUMA_MAX_DISPLAYABLE_OBJECTS, sizeof(NI_element *));
04771    if (!nelv) {
04772       SUMA_SLP_Crit("Failed to allocate");
04773       SUMA_RETURN(NULL);
04774    }
04775    
04776    NeverReplace = NOPE;
04777    AlwaysReplace = NOPE;
04778    inel = 0;
04779    do {
04780       nel = NI_read_element(ns,1) ;
04781       
04782       if (nel) {
04783          found = YUP;
04784          
04785          if (LocalHead && 0) SUMA_nel_stdout (nel);
04786          
04787          if (strcmp(nel->name,SUMA_Dset_Type_Name(SUMA_NODE_ROI))) {
04788             SUMA_SLP_Err ("ni element not of the \n Node ROI variety.\nElement discarded.");
04789             NI_free_element(nel) ; nel = NULL;
04790             SUMA_RETURN(NULL);
04791          }
04792          /* somewhat redundant test */
04793          if (nel->vec_typ[0] != SUMAg_CF->nimlROI_Datum_type) {
04794             SUMA_SLP_Err ("Datum type mismatch.");
04795             NI_free_element(nel) ; nel = NULL;
04796             SUMA_RETURN(NULL);
04797          }
04798 
04799          if (ForDisplay) {
04800             /* find out if a displayable object exists with the same idcode_str */
04801             nel_idcode = NI_get_attribute( nel , "idcode_str"); /* obsolete*/
04802             if (!nel_idcode) nel_idcode = NI_get_attribute( nel , "Object_ID"); 
04803             if (SUMA_existDO(nel_idcode, SUMAg_DOv, SUMAg_N_DOv)) {
04804                if (AlwaysReplace) {
04805                   AddNel = YUP; 
04806                }
04807                if (NeverReplace) {
04808                   AddNel = NOPE;
04809                }
04810                if (!AlwaysReplace && !NeverReplace) {   /* ASk */
04811                   sprintf(stmp, "Found duplicate ROIs.\n"\
04812                                              "Replace ROI %s (%s) by\n" \
04813                                              "version in file ?", 
04814                   NI_get_attribute( nel , "Label"), nel_idcode); 
04815 
04816                   answer = SUMA_ForceUser_YesNo (SUMAg_SVv[0].X->TOPLEVEL, 
04817                                     stmp, 
04818                                     0, SWP_DONT_CARE);
04819                   if (LocalHead) fprintf (SUMA_STDERR,"%s: Got %d, You ?\n", FuncName, answer);
04820                   switch (answer) {
04821                      case SUMA_YES:
04822                         SUMA_LH("YES");
04823                         AddNel = YUP;
04824                         break;
04825 
04826                      case SUMA_NO:
04827                         SUMA_LH("NO");
04828                         /* don't add this one */
04829                         AddNel = NOPE;
04830                         break;
04831 
04832                      case SUMA_YES_ALL:
04833                         SUMA_LH("YES ALL");
04834                         /* cancel Check_Prior */
04835                         AddNel = YUP;
04836                         AlwaysReplace = YUP;
04837                         break;
04838 
04839                      case SUMA_NO_ALL:
04840                         SUMA_LH("NO ALL");
04841                         /* don't add this one and set flag to ignore the doubles */
04842                         AddNel = NOPE;
04843                         NeverReplace = YUP;
04844                         break;
04845 
04846                      default:
04847                         SUMA_SLP_Crit("Don't know what to do with this button.");
04848                         SUMA_RETURN(NULL);
04849                         break;
04850                   }
04851                } 
04852             } else {
04853                AddNel = YUP;
04854             } 
04855          
04856             /* make sure element's parent exists */
04857             if (AddNel) {
04858                SUMA_LH("Checking for Parent surface...");
04859                iDO = SUMA_whichDO(NI_get_attribute( nel , "Parent_idcode_str"), SUMAg_DOv, SUMAg_N_DOv); /* obsolete */
04860                if (iDO < 0) iDO = SUMA_whichDO(NI_get_attribute( nel , "Parent_ID"), SUMAg_DOv, SUMAg_N_DOv);
04861               
04862                if (iDO < 0) {
04863                   SUMA_SLP_Err(  "ROI's parent surface\n"
04864                                  "is not loaded. ROI is\n"
04865                                  "discarded." );
04866                   AddNel = NOPE;
04867                }
04868             }
04869          } else {
04870             AddNel = YUP; /* ignore checks */
04871          }         
04872          
04873          if (AddNel) {
04874             SUMA_LH("Adding Nel");
04875             nelv[inel] = nel;
04876             ++inel; 
04877          }else {
04878             SUMA_LH("Skipping Nel");
04879          }
04880          
04881          ++n_read;
04882       }else {
04883          found = NOPE;
04884       } 
04885       
04886    } while (found);
04887    
04888    NI_stream_close(ns) ;
04889    N_nel = inel;
04890    
04891    if( !n_read){
04892       SUMA_SL_Err("Found no elements in file!"); 
04893       SUMA_free(nelv);
04894       SUMA_RETURN(NULL);
04895    }
04896    
04897    /* Now turn those nel into ROIS */
04898    ROIv = (SUMA_DRAWN_ROI **) SUMA_malloc(N_nel*sizeof(SUMA_DRAWN_ROI*));
04899    for (inel=0; inel < N_nel; ++inel) {
04900       if (LocalHead) fprintf (SUMA_STDERR,"%s: Processing nel %d/%d...\n", FuncName, inel, N_nel);
04901       nel = nelv[inel];
04902       nel_idcode = NI_get_attribute( nel , "idcode_str"); /* obsolete */
04903       if (!nel_idcode) nel_idcode = NI_get_attribute( nel , "Object_ID"); 
04904 
04905       /* store nel in nimlROI struct */
04906 
04907       /* allocate for nimlROI */
04908       nimlROI = (SUMA_NIML_DRAWN_ROI *)SUMA_malloc(sizeof(SUMA_NIML_DRAWN_ROI));
04909       nimlROI->Type = (int)strtod(NI_get_attribute( nel , "Type"), NULL);
04910       nimlROI->idcode_str = SUMA_copy_string(NI_get_attribute( nel , "idcode_str")); /* obsolete */
04911       if (SUMA_IS_EMPTY_STR_ATTR(nimlROI->idcode_str)) nimlROI->idcode_str = SUMA_copy_string(NI_get_attribute( nel , "Object_ID"));
04912       nimlROI->Parent_idcode_str = SUMA_copy_string(NI_get_attribute( nel , "Parent_idcode_str")); /* obsolete */
04913       if (SUMA_IS_EMPTY_STR_ATTR(nimlROI->Parent_idcode_str)) nimlROI->Parent_idcode_str = SUMA_copy_string(NI_get_attribute( nel , "Parent_ID"));
04914       nimlROI->Label = SUMA_copy_string(NI_get_attribute( nel , "Label"));
04915       nimlROI->iLabel = (int)strtod(NI_get_attribute( nel , "iLabel"), NULL);
04916       nimlROI->N_ROI_datum = nel->vec_len;
04917       nimlROI->ColPlaneName = SUMA_copy_string(NI_get_attribute( nel , "ColPlaneName"));
04918       if (SUMA_StringToNum (NI_get_attribute( nel , "FillColor"), 
04919                            nimlROI->FillColor, 3) < 0) {
04920          SUMA_SLP_Err("Failed in reading FillColor.");
04921          SUMA_free(nelv);
04922          SUMA_RETURN(NULL);
04923       }
04924       if (SUMA_StringToNum (NI_get_attribute( nel , "EdgeColor"), 
04925                            nimlROI->EdgeColor, 3) < 0) {
04926          SUMA_SLP_Err("Failed in reading EdgeColor.");
04927          SUMA_free(nelv);
04928          SUMA_RETURN(NULL);
04929       }
04930       nimlROI->EdgeThickness = (int)strtod(NI_get_attribute( nel , "EdgeThickness"), NULL);              
04931       
04932       if (LocalHead) {
04933          fprintf (SUMA_STDERR,"%s: vec_type[0] = %d (%d)\n", 
04934             FuncName, nel->vec_typ[0], SUMAg_CF->nimlROI_Datum_type) ;
04935          fprintf (SUMA_STDERR,"%s: vec_len =%d\tvec_num = %d\nidcode_str %s, Parent_idcode_str %s\n",
04936             FuncName, nel->vec_len, nel->vec_num,
04937             nimlROI->idcode_str, nimlROI->Parent_idcode_str);
04938       }
04939 
04940       nimlROI->ROI_datum = (SUMA_NIML_ROI_DATUM *)SUMA_malloc(nimlROI->N_ROI_datum*sizeof(SUMA_NIML_ROI_DATUM));
04941 
04942       /* DO NOT use niml_ROI_datum_buff = (SUMA_NIML_ROI_DATUM *)nel->vec[idat];
04943       inside the loop.
04944       For the SUMA_NIML_DRAWN_ROI you have one column of (SUMA_NIML_ROI_DATUM *)
04945       ni_type = "SUMA_NIML_ROI_DATUM". If you had for type:
04946       "SUMA_NIML_ROI_DATUM, int" then you'd have two columns with the second
04947       column being a vector of ints. The only caveat is that the second column
04948       must be of equal length to the first. */
04949       niml_ROI_datum_buff = (SUMA_NIML_ROI_DATUM *)nel->vec[0]; 
04950       /* now fill the ROI_datum structures */
04951       SUMA_LH("Filling ROI datum structures...");
04952       for (idat=0; idat< nimlROI->N_ROI_datum ; ++idat) {
04953          if (LocalHead) fprintf (SUMA_STDERR,"%s: i=%d\n", FuncName, idat);
04954          nimlROI->ROI_datum[idat].action = niml_ROI_datum_buff[idat].action;
04955          nimlROI->ROI_datum[idat].Type = niml_ROI_datum_buff[idat].Type;
04956          nimlROI->ROI_datum[idat].N_n = niml_ROI_datum_buff[idat].N_n;
04957          if (nimlROI->ROI_datum[idat].N_n > 0) {
04958             if (LocalHead) fprintf (SUMA_STDERR,"%s: Copying nPath, %d values\n", FuncName, nimlROI->ROI_datum[idat].N_n);
04959             nimlROI->ROI_datum[idat].nPath = (int *)SUMA_malloc(sizeof(int)*nimlROI->ROI_datum[idat].N_n);
04960             memcpy(nimlROI->ROI_datum[idat].nPath, niml_ROI_datum_buff[idat].nPath, sizeof(int)*nimlROI->ROI_datum[idat].N_n);
04961          } else {
04962             SUMA_LH("Null nPath");
04963             nimlROI->ROI_datum[idat].nPath = NULL;
04964          } 
04965          if (LocalHead) { 
04966             fprintf (SUMA_STDERR,"%s: Segment %d\tType %d\tN_n %d\taction %d\n", 
04967                FuncName, idat, nimlROI->ROI_datum[idat].Type,  
04968                nimlROI->ROI_datum[idat].N_n,nimlROI->ROI_datum[idat].action);
04969          }
04970       }
04971 
04972       /* Does ROI already exist with the same idcode_str ?*/
04973       
04974       SUMA_LH("Checking for duplicates...");
04975       if ((iDO = SUMA_whichDO(nel_idcode, SUMAg_DOv, SUMAg_N_DOv)) >= 0) {
04976          SUMA_LH("Duplicate found ... Deleteing old one...");
04977          /* ROI already exists delete it */
04978          if (!SUMA_DeleteROI ((SUMA_DRAWN_ROI *)SUMAg_DOv[iDO].OP)) {
04979             SUMA_SLP_Err("Failed to delete ROI");
04980             SUMA_RETURN(NULL); 
04981          }
04982       }
04983       
04984       /* transfom nimlROI to a series of drawing actions */
04985       SUMA_LH("Transforming ROI to a series of actions...");
04986       ROIv[inel] = SUMA_NIMLDrawnROI_to_DrawnROI (nimlROI, ForDisplay);
04987       if (LocalHead) fprintf (SUMA_STDERR, "%s: ROI->Parent_idcode_str %s\n", FuncName, ROIv[inel]->Parent_idcode_str);
04988 
04989       /* manually free nimlROI fields that received copies of allocated space as opposed to pointer copies */
04990       if (nimlROI->idcode_str) SUMA_free(nimlROI->idcode_str);
04991       if (nimlROI->Parent_idcode_str) SUMA_free(nimlROI->Parent_idcode_str); 
04992       if (nimlROI->Label) SUMA_free(nimlROI->Label);
04993       if (nimlROI->ColPlaneName) SUMA_free(nimlROI->ColPlaneName);
04994 
04995 
04996       /* free nimlROI */
04997       nimlROI = SUMA_Free_NIMLDrawROI(nimlROI);
04998 
04999       /* free nel and get it ready for the next load */
05000       NI_free_element(nel) ; nel = NULL; 
05001             
05002    }
05003    
05004    /* free nelv */
05005    SUMA_free(nelv);
05006    
05007    *N_ROI = N_nel;
05008    SUMA_RETURN(ROIv);
05009 } 

07685 {
07686    static char FuncName[]={"SUMA_OpenDx_Object_Attr"};
07687    int i, Found, ival,imax;
07688    char *op_end, cend, *op2, *sval;
07689    char *op_orig;
07690    SUMA_Boolean LocalHead = NOPE;
07691    
07692    SUMA_ENTRY;
07693    
07694    /* get the attributes */
07695    
07696    op_orig = op; /* hide this pointer from the evils that will befall it */
07697    cend = op_orig[nchar-1]; op_orig[nchar-1] = '\0';
07698    op_end = op_orig + nchar - 1; 
07699    
07700    SUMA_ADVANCE_PAST(op,op_end,"attribute",Found, 1);
07701    sval = NULL;
07702    while (Found) {
07703       /* get the attribute's name */
07704       SUMA_GET_BETWEEN_BLANKS(op, op_end, op2);
07705       if (op2 == op) {
07706          SUMA_LH("Empty attribute?");
07707       } else {
07708          imax = op2 - op;
07709          if (imax > 5000) {
07710             SUMA_SL_Err("Unexpectedly large field!");
07711             op_orig[nchar-1] =  cend;
07712             SUMA_RETURN(NOPE);
07713          }else if (imax < 0) {
07714             SUMA_SL_Err("Negative imax!");
07715             op_orig[nchar-1] =  cend;
07716             SUMA_RETURN(NOPE);
07717          }
07718          sval = (char *)SUMA_calloc(imax + 2, sizeof(char));
07719 
07720          for (i=0; i < imax; ++i) sval[i] = op[i];
07721          sval[imax] = '\0';
07722          dx->attr_name[dx->n_attr] = sval;
07723       }
07724       op = op2;
07725       /* look for attribute string */
07726       SUMA_ADVANCE_PAST(op,op_end,"string",Found,1);
07727       if (Found) {
07728          SUMA_GET_BETWEEN_BLANKS(op, op_end, op2);
07729          if (op2 == op) {
07730             SUMA_LH("Empty string?");
07731          } else {
07732             imax = op2 - op;
07733             if (imax > 5000) {
07734                SUMA_SL_Err("Unexpectedly large field!");
07735                op_orig[nchar-1] =  cend;
07736                SUMA_RETURN(NOPE);
07737             }else if (imax < 0) {
07738                SUMA_SL_Err("Negative imax!");
07739                op_orig[nchar-1] =  cend;
07740                SUMA_RETURN(NOPE);
07741             }
07742             sval = (char *)SUMA_calloc(imax + 2, sizeof(char));
07743 
07744             for (i=0; i < imax; ++i) sval[i] = op[i];
07745             sval[imax] = '\0';
07746             dx->attr_string[dx->n_attr] = sval;
07747          }   
07748       }
07749       ++dx->n_attr;
07750       /* look for next attribute */
07751       op = op2;
07752       SUMA_ADVANCE_PAST(op,op_end,"attribute",Found,1);
07753    }
07754       
07755    op_orig[nchar-1] =  cend;
07756    SUMA_RETURN(YUP);
07757 }

07762 {
07763    static char FuncName[]={"SUMA_OpenDx_Object_Components"};
07764    int i, Found, ival,imax;
07765    char *op_end, cend, *op2, *sval;
07766    char *op_orig;
07767    SUMA_Boolean LocalHead = NOPE;
07768    
07769    SUMA_ENTRY;
07770    
07771    /* get the attributes */
07772    
07773    op_orig = op; /* hide this pointer from the evils that will befall it */
07774    cend = op_orig[nchar-1]; op_orig[nchar-1] = '\0';
07775    op_end = op_orig + nchar - 1; 
07776    
07777    SUMA_ADVANCE_PAST(op,op_end,"component",Found,1);
07778    while (Found) {
07779       /* get the attribute's name */
07780       SUMA_GET_BETWEEN_BLANKS(op, op_end, op2);
07781       if (op2 == op) {
07782          SUMA_LH("Empty component?");
07783       } else {
07784          imax = op2 - op;
07785          if (imax > 5000) {
07786             SUMA_SL_Err("Unexpectedly large field!");
07787             op_orig[nchar-1] =  cend;
07788             SUMA_RETURN(NOPE);
07789          }else if (imax < 0) {
07790             SUMA_SL_Err("Negative imax!");
07791             op_orig[nchar-1] =  cend;
07792             SUMA_RETURN(NOPE);
07793          }
07794          sval = (char *)SUMA_calloc(imax + 2, sizeof(char));
07795 
07796          for (i=0; i < imax; ++i) sval[i] = op[i];
07797          sval[imax] = '\0';
07798          dx->comp_name[dx->n_comp] = sval;
07799       }
07800       op = op2;
07801       /* look for attribute string */
07802       SUMA_ADVANCE_PAST(op,op_end,"value",Found,1);
07803       if (Found) {
07804          SUMA_GET_BETWEEN_BLANKS(op, op_end, op2);
07805          if (op2 == op) {
07806             SUMA_SL_Err("No value!");
07807          } else {
07808             imax = op2 - op;
07809             if (imax > 5000) {
07810                SUMA_SL_Err("Unexpectedly large field!");
07811                op_orig[nchar-1] =  cend;
07812                SUMA_RETURN(NOPE);
07813             }else if (imax < 0) {
07814                SUMA_SL_Err("Negative imax!");
07815                op_orig[nchar-1] =  cend;
07816                SUMA_RETURN(NOPE);
07817             }
07818             sval = (char *)SUMA_calloc(imax + 2, sizeof(char));
07819 
07820             for (i=0; i < imax; ++i) sval[i] = op[i];
07821             sval[imax] = '\0';
07822             dx->comp_value[dx->n_comp] = sval;
07823          }   
07824       }else { /* try for non-existing "value" */
07825          SUMA_GET_BETWEEN_BLANKS(op, op_end, op2);
07826          if (op2 == op) {
07827             SUMA_SL_Err("No value at all");
07828          } else {
07829             imax = op2 - op;
07830             if (imax > 5000) {
07831                SUMA_SL_Err("Unexpectedly large field!");
07832                op_orig[nchar-1] =  cend;
07833                SUMA_RETURN(NOPE);
07834             }else if (imax < 0) {
07835                SUMA_SL_Err("Negative imax!");
07836                op_orig[nchar-1] =  cend;
07837                SUMA_RETURN(NOPE);
07838             }
07839             sval = (char *)SUMA_calloc(imax + 2, sizeof(char));
07840 
07841             for (i=0; i < imax; ++i) sval[i] = op[i];
07842             sval[imax] = '\0';
07843             dx->comp_value[dx->n_comp] = sval;
07844          }   
07845       }
07846       ++dx->n_comp;
07847       /* look for next component */
07848       op = op2;
07849       SUMA_ADVANCE_PAST(op,op_end,"component",Found,1);
07850    }
07851       
07852    op_orig[nchar-1] =  cend;
07853    SUMA_RETURN(YUP);
07854 }

07584 {
07585    static char FuncName[]={"SUMA_OpenDx_Object_Data"};
07586    int i, Found = 0, ival;
07587    char *op_end, cend, *op2, *sval;
07588    char *op_orig;
07589    SUMA_Boolean LocalHead = NOPE;
07590    
07591    SUMA_ENTRY;
07592    
07593    /* get the data */
07594    op_orig = op; /* hide this pointer from the evils that will befall it */
07595    cend = op_orig[nchar-1]; op_orig[nchar-1] = '\0';
07596    op_end = op_orig + nchar - 1; 
07597    if (LocalHead) { /* potential for huge dump if you set show to nchar! */
07598          int j, show;
07599          show = 500; /* could also use nchar */
07600          fprintf(SUMA_STDERR,"%s Object\n", FuncName);
07601          j=0; while (op[j] && j<500) { fprintf(SUMA_STDERR,"%c", op[j]); ++j; }
07602          fprintf(SUMA_STDERR,"\n");
07603    }
07604    SUMA_ADVANCE_PAST(op,op_end,"data",Found,1);
07605    sval = NULL;
07606    if (Found) {
07607       /* get the data's info */
07608       SUMA_GET_BETWEEN_BLANKS(op, op_end, op2);
07609       if (op2 == op) {
07610          SUMA_LH("Empty data?");
07611          dx->data=NULL;
07612       } else {
07613          SUMA_COPY_TO_STRING(op, op2, sval);
07614          dx->data = sval; sval = NULL;
07615       }
07616       op = op2;
07617       /* now fill datap if possible*/
07618       if (dx->data && strstr(dx->data,"follows")){
07619          int nread=0;
07620          SUMA_LH("data inside");
07621          if (LocalHead) { /* potential for huge dump! */
07622             int j, show;
07623             show = 500; /* could also use nchar */
07624             fprintf(SUMA_STDERR,"%s Object\n", FuncName);
07625             j=0; while (op[j] && j<500) { fprintf(SUMA_STDERR,"%c", op[j]); ++j; }
07626             fprintf(SUMA_STDERR,"\n");
07627          }  
07628          dx->datap = SUMA_strtol_vec(op, dx->items*SUMA_NCOL_OPENDX(dx), &nread, SUMA_VarType2TypeCast (dx->type));
07629          if (LocalHead) {
07630             fprintf(SUMA_STDERR,"%s: Read %d/%d values\n", FuncName, nread, dx->items*SUMA_NCOL_OPENDX(dx));
07631          }
07632          if (nread != dx->items*SUMA_NCOL_OPENDX(dx)) {
07633             fprintf(SUMA_STDERR,"Error %s: read in %d values, expected %d \n", FuncName, nread, dx->items*SUMA_NCOL_OPENDX(dx));
07634             op_orig[nchar-1] =  cend;
07635             SUMA_RETURN(NOPE);
07636          }
07637       }else {
07638          SUMA_LH("data does not follow");
07639          if (LocalHead) {
07640             for (i=0; i < 500; ++i) { fprintf(SUMA_STDERR,"%c", op[i]); } fprintf(SUMA_STDERR,"\n"); fflush(SUMA_STDERR);
07641          }
07642          /* ? have file name ? */
07643          if (strstr(dx->data,"file")) {
07644             SUMA_GET_BETWEEN_BLANKS(op, op_end, op2);
07645             if (op2 > op) {
07646                SUMA_free(dx->data); /* free the "file" string */
07647                SUMA_COPY_TO_STRING(op, op2, sval);
07648                dx->data = sval; sval = NULL;
07649                /* search backwards for a comma */
07650                i=strlen(dx->data)-1; Found = -1;
07651                while(i>=0 && Found <0) { if (dx->data[i] == ',') Found = i; --i; }
07652                if (Found >= 0) { 
07653                   dx->data_off = SUMA_copy_string(&(dx->data[Found+1]));
07654                   dx->data[Found]='\0';
07655                }  
07656                /* see if you have some byte order or binary business */
07657                dx->data_format = 0; /* ascii, default*/
07658                op = op_orig; SUMA_ADVANCE_PAST(op,op_end,"binary",Found,1);
07659                if (Found) {
07660                   dx->data_format = MSB_FIRST; /* default */
07661                }
07662                /* endianness, regardless of what was above, "binary" might not occur */
07663                op = op_orig; SUMA_ADVANCE_PAST(op,op_end,"msb",Found,1);
07664                if (Found) { dx->data_format = MSB_FIRST; }
07665                else {
07666                   op = op_orig; SUMA_ADVANCE_PAST(op,op_end,"lsb",Found,1);
07667                   if (Found) { dx->data_format = LSB_FIRST; }
07668                }
07669             }
07670          }
07671       }
07672    } else {
07673       SUMA_LH("No data for this object");
07674    }
07675       
07676    op_orig[nchar-1] =  cend;
07677    SUMA_RETURN(YUP);
07678 }

07868 {
07869    static char FuncName[]={"SUMA_OpenDx_Object_Header_Field"};
07870    void *ans=NULL;
07871    int i, Found, ival, imax, nread;
07872    char *op_end = NULL, cend, *op2, *sval, *pp1, *pp2;
07873    char *op_orig;
07874    SUMA_Boolean LocalHead = NOPE;
07875    
07876    SUMA_ENTRY;
07877    
07878    if (opeofield) *opeofield = op;
07879    
07880    if (!attr) SUMA_RETURN(ans);
07881    op_orig = op; /* hide this pointer from the evils that will befall it */
07882    cend = op_orig[nchar-1]; op_orig[nchar-1] = '\0';
07883    /* do we have a data section to signal end of header? */
07884    op_end = NULL;
07885    pp1 = strstr(op, "data"); 
07886    if (pp1) {
07887       pp2 = strstr(op, "follows");
07888       if (pp2) op_end = pp2;
07889    }
07890    if (!op_end) op_end = op_orig + nchar - 1; /* op_end all the way at end */
07891    
07892    if (LocalHead) {
07893       fprintf(SUMA_STDERR,"%s: Object of %d chars, looking for >>>%s<<<\n", FuncName, nchar, attr );
07894    }
07895    
07896   /* get the header field's value name */
07897    SUMA_ADVANCE_PAST(op,op_end,attr,Found,1);
07898    if (Found) {
07899       SUMA_GET_BETWEEN_BLANKS(op, op_end, op2);
07900       if (op2 == op) {
07901          SUMA_LH("No field");
07902       } else {
07903          /* get the numeric fields changed*/
07904          if (strstr(attr,"rank") || strstr(attr,"shape") || strstr(attr,"items")) { /* rank, shape (matrix's second dim) are integer vals */
07905             ival = (int)strtol(op, NULL , 10);
07906             ans = (void*)&ival;
07907          } else if (strstr(attr,"counts")) { /* are a series integer vals */
07908             ans = SUMA_AdvancePastNumbers(op, &op2, SUMA_int);
07909          } else if (strstr(attr,"origin") || strstr(attr,"delta")) { /* are integer vals */
07910             ans = SUMA_AdvancePastNumbers(op, &op2, SUMA_float);
07911          } else  { /* strings*/
07912             imax = op2 - op;
07913             if (imax > 5000) {
07914                SUMA_SL_Err("Unexpectedly large field!");
07915                op_orig[nchar-1] =  cend;
07916                SUMA_RETURN(ans);
07917             }else if (imax < 0) {
07918                SUMA_SL_Err("Negative imax!");
07919                op_orig[nchar-1] =  cend;
07920                SUMA_RETURN(ans);
07921             }
07922             sval = (char *)SUMA_calloc(imax + 2, sizeof(char));
07923             
07924             for (i=0; i < imax; ++i) sval[i] = op[i];
07925             sval[imax] = '\0';
07926             ans = (void*)&sval;
07927          }    
07928          if (LocalHead) {
07929             fprintf(SUMA_STDERR,"%s: attribute >>>%s<<< is:\n", FuncName, attr);
07930             i = 0;
07931             while (op[i] && op+i != op2) {
07932                fprintf(SUMA_STDERR,"%c", op[i]); 
07933                ++i;   
07934             }
07935             fprintf(SUMA_STDERR,"\n");
07936          }
07937          
07938       }
07939       op = op2; /* advance op */
07940    } else {
07941       if (strstr(attr,"class")) {
07942          /* it looks like "class" is sometimes omitted, look for string field, which is a class */
07943          SUMA_ADVANCE_PAST(op,op_end,"field", Found,1);
07944          if (Found) sval = SUMA_copy_string("field");
07945          ans = (void*)&sval;
07946       } else {
07947          SUMA_LH("No such attribute");
07948       }
07949    }
07950       
07951    op_orig[nchar-1] =  cend;
07952    if (opeofield) *opeofield = op; 
07953    SUMA_RETURN(ans);
07954 }

07959 {
07960    static char FuncName[]={"SUMA_OpenDX_Read"};
07961    int nread = 0, i = 0,  iop, *ivalp=NULL, shft=0;
07962    char *fl=NULL, **opv = NULL, *op = NULL,*sbuf=NULL, **svalp=NULL, *ope;
07963    int *nchar = NULL;
07964    SUMA_OPEN_DX_STRUCT **dxv=NULL;
07965    SUMA_FVEC *fvec=NULL;
07966    SUMA_IVEC *ivec=NULL;
07967    SUMA_Boolean LocalHead = NOPE;
07968    
07969    SUMA_ENTRY;
07970    
07971    *nobj = 0;
07972    
07973    SUMA_LH("Sucking file");
07974    nread = SUMA_suck_file( fname , &fl ) ;
07975    if (!fl) {
07976       SUMA_SL_Err("Failed to read file.");
07977       SUMA_RETURN(dxv);
07978    }
07979 
07980    if (LocalHead) fprintf(SUMA_STDERR,"%s: Read in %d chars\n", FuncName, nread);
07981    
07982    opv = (char **)SUMA_calloc(SUMA_MAX_OPEN_DX_OBJECTS, sizeof(char*));
07983    nchar = (int*)SUMA_calloc(SUMA_MAX_OPEN_DX_OBJECTS, sizeof(int));
07984    dxv = (SUMA_OPEN_DX_STRUCT **)SUMA_calloc(SUMA_MAX_OPEN_DX_OBJECTS, sizeof(SUMA_OPEN_DX_STRUCT *));
07985    
07986    /* now search for the first "object" */
07987    op = fl;
07988    iop = 0;
07989    shft = 0;
07990    do {
07991       op = strstr((op+shft), "object");
07992       if (op) {
07993          opv[iop] = op;
07994          if (iop) nchar[iop-1] = opv[iop] - opv[iop-1];
07995          if (LocalHead) {
07996             fprintf(SUMA_STDERR,"%s: Object found.\n", FuncName);
07997             i = 0;
07998             while (i<20 && op[i] !='\0') { fprintf(SUMA_STDERR,"%c",op[i]); ++i; } fprintf(SUMA_STDERR,"\n"); 
07999          }
08000          
08001          /* must skip beyond first "object" for next pass*/
08002          shft = strlen("object");
08003          ++iop;
08004       }
08005    } while (op && iop < SUMA_MAX_OPEN_DX_OBJECTS);
08006    if (iop >= SUMA_MAX_OPEN_DX_OBJECTS) {
08007       SUMA_SL_Warn("Too many objects, processing first SUMA_MAX_OPEN_DX_OBJECTS only"); 
08008    }
08009    
08010    if (iop) {/* find the length of the last object */
08011       op = opv[iop-1];
08012       while (*op !='\0') { ++op; }
08013       nchar[iop-1] = op - opv[iop-1];
08014    }
08015    
08016    if (LocalHead) {
08017       fprintf(SUMA_STDERR,"%s: %d Objects found.\n", FuncName, iop);
08018    }
08019    
08020    for (i=0; i<iop; ++i) { /* process each object's header field and data*/
08021       if ( 0 && LocalHead) { /* potentially huge dump if nmax is not controlled*/
08022          int j, nmax;
08023          nmax = 500; /* could also use nchar[i]*/
08024          fprintf(SUMA_STDERR,"%s Object %d\n", FuncName, i);
08025          op = opv[i]; for (j=0; j<nmax; ++j) fprintf(SUMA_STDERR,"%c", op[j]);
08026          fprintf(SUMA_STDERR,"\n");
08027       }
08028       /* get the class */
08029       dxv[i] = SUMA_Alloc_OpenDX_Struct();
08030       ivalp = (int *)SUMA_OpenDx_Object_Header_Field(opv[i], nchar[i], "rank", NULL);
08031       if (ivalp) dxv[i]->rank = *ivalp;
08032       ivalp = (int *)SUMA_OpenDx_Object_Header_Field(opv[i], nchar[i], "shape", NULL);
08033       if (ivalp) dxv[i]->shape = *ivalp;
08034       ivalp = (int *)SUMA_OpenDx_Object_Header_Field(opv[i], nchar[i], "items", NULL);
08035       if (ivalp) dxv[i]->items = *ivalp;
08036       svalp = (char **)SUMA_OpenDx_Object_Header_Field(opv[i], nchar[i], "object", NULL);
08037       if (svalp) dxv[i]->object = *svalp;
08038       svalp = (char **)SUMA_OpenDx_Object_Header_Field(opv[i], nchar[i], "class", NULL);
08039       if (svalp) dxv[i]->class = *svalp;
08040       svalp = (char **)SUMA_OpenDx_Object_Header_Field(opv[i], nchar[i], "type", NULL);
08041       if (svalp) dxv[i]->type = *svalp;
08042       ivec = (SUMA_IVEC*)SUMA_OpenDx_Object_Header_Field(opv[i], nchar[i], "counts", NULL);
08043       if (ivec) { dxv[i]->counts = ivec->v; dxv[i]->n_counts = ivec->n; SUMA_free(ivec); ivec = NULL;} 
08044       fvec = (SUMA_FVEC*)SUMA_OpenDx_Object_Header_Field(opv[i], nchar[i], "origin", NULL);
08045       if (fvec) { dxv[i]->origin = fvec->v; dxv[i]->n_origin = fvec->n; SUMA_free(fvec); fvec = NULL;} 
08046       { /* get the deltas */
08047          int j, k;
08048          char *rf=opv[i];
08049          j=0; 
08050          while (j<dxv[i]->n_counts) {
08051             fvec = (SUMA_FVEC*)SUMA_OpenDx_Object_Header_Field(rf, nchar[i], "delta", &ope);
08052             if (fvec && fvec->v) { 
08053                if (fvec->n < dxv[i]->n_counts) { SUMA_SL_Warn("Bad assumption about delta field.\nExpect disasters!"); }
08054                if (fvec->n > dxv[i]->n_counts) { 
08055                   SUMA_SL_Err("More values in delta that counts! Limiting to counts.\nExpect tragedy."); 
08056                   fvec->n = dxv[i]->n_counts;
08057                }
08058                if (j==0) { /* allocate */ 
08059                   dxv[i]->n_delta = dxv[i]->n_counts*dxv[i]->n_counts; 
08060                   dxv[i]->delta = (float *)SUMA_calloc(dxv[i]->n_delta, sizeof(float));
08061                }
08062                for (k=0; k<fvec->n; ++k) { 
08063                   dxv[i]->delta[(j*dxv[i]->n_counts) + k] = fvec->v[k];  
08064                }
08065                SUMA_free(fvec->v); SUMA_free(fvec); fvec = NULL;
08066             } else { /* get out */
08067                if (j) {
08068                   SUMA_SL_Warn("Expect as many deltas as counts!\nThat was not the case.");
08069                } else { /* OK, no deltas at all */ }
08070                j = dxv[i]->n_counts;
08071             }
08072             ++j; rf = ope;
08073          }
08074       } 
08075       /* now for the data */
08076       if (!SUMA_OpenDx_Object_Data(opv[i], nchar[i], dxv[i])) {
08077          SUMA_SL_Err("Failed to get data");
08078          dxv[i]->bad_data = 1;
08079       }
08080    }
08081 
08082    for (i=0; i<iop; ++i) { /* process each object's attributes*/
08083       if (!SUMA_OpenDx_Object_Attr(opv[i], nchar[i], dxv[i])) {
08084          SUMA_SL_Err("Failed in SUMA_OpenDx_Object_Attr");
08085       }
08086       if (!SUMA_OpenDx_Object_Components(opv[i], nchar[i], dxv[i])) {
08087          SUMA_SL_Err("Failed in SUMA_OpenDx_Object_Components");
08088       }
08089    }
08090 
08091    if (LocalHead) {
08092          SUMA_Show_OpenDX_Struct(dxv, iop, NULL); fflush(stdout);
08093    }
08094    
08095    if (opv) SUMA_free(opv); opv = NULL;
08096    if (nchar) SUMA_free(nchar); nchar = NULL;
08097    if (fl) SUMA_free(fl); fl = NULL; /* added Mon May 9 05, ZSS */
08098    *nobj = iop;
08099    SUMA_RETURN(dxv); 
08100 }

08153 {
08154    static char FuncName[]={"SUMA_OpenDX_Read_CruiseVolHead"};
08155    int i = 0, nf, iop, chunk, End, bs, doff, data_type=SUMA_notypeset;
08156    THD_ivec3 iv3;
08157    THD_mat33 m33;
08158    THD_ivec3 orixyz , nxyz ;
08159    THD_fvec3 dxyz , orgxyz ;
08160    float ep[3], sp[3];
08161    char *scom=NULL, form[10], swp[10], orstr[10], xfov[100], yfov[100], zfov[100], *prefix = NULL, *dsetheadname = NULL;
08162    SUMA_OPEN_DX_STRUCT **dxv=NULL, *dxp=NULL, *dxc=NULL, *dxf=NULL, *dxa=NULL;
08163    SUMA_Boolean LocalHead = NOPE;
08164    
08165    SUMA_ENTRY;
08166    
08167    if (!dset || !fname) {
08168       SUMA_SL_Err("NULL fname || NULL dset!");
08169       SUMA_RETURN(NOPE);
08170    }
08171    
08172    prefix = SUMA_AfniPrefix(fname, NULL, NULL, NULL);
08173    if( !THD_filename_ok(prefix) ) {
08174       SUMA_SL_Err("Bad prefix");
08175       SUMA_RETURN(NOPE);
08176    } 
08177    dsetheadname = SUMA_append_string(prefix,"+orig.HEAD");
08178    if (SUMA_filexists(dsetheadname)) {
08179       SUMA_SL_Err("Bad prefix, output dset exists");
08180       SUMA_RETURN(NOPE);
08181    }
08182    SUMA_free(dsetheadname); dsetheadname = NULL;
08183    
08184    SUMA_LH("Reading objects");
08185    dxv = SUMA_OpenDX_Read(fname, &iop);
08186    if (!dxv) {
08187       SUMA_SL_Err("Failed to read DX file.");
08188       SUMA_RETURN(NOPE);
08189    }
08190    
08191    SUMA_LH("Checking for field object");
08192    dxf = SUMA_Find_OpenDX_Object_Class(dxv, iop, "field", &nf);
08193    if (!dxf || nf != 1) { SUMA_SL_Err("Failed to find one and only one field object"); goto CLEAN_EXIT; }
08194    dxp = dxc = NULL;   
08195    for (i=0; i<dxf->n_comp; ++i) {
08196       if (strstr(dxf->comp_name[i],"positions")) {
08197          dxp = SUMA_Find_OpenDX_Object_Name(dxv, iop, dxf->comp_value[i], &nf); 
08198          if (!dxp || nf != 1) { SUMA_SL_Err("Failed to find one and only one positions object"); goto CLEAN_EXIT; }
08199       }
08200       if (strstr(dxf->comp_name[i],"connections")) {
08201          dxc = SUMA_Find_OpenDX_Object_Name(dxv, iop, dxf->comp_value[i], &nf); 
08202          if (!dxc || nf != 1) { SUMA_SL_Err("Failed to find one and only one connections object"); goto CLEAN_EXIT; }
08203       }
08204       if (strstr(dxf->comp_name[i],"data")) {
08205          dxa = SUMA_Find_OpenDX_Object_Name(dxv, iop, dxf->comp_value[i], &nf); 
08206          if (!dxa || nf != 1) { SUMA_SL_Err("Failed to find one and only one data object"); goto CLEAN_EXIT; }
08207       }
08208    }
08209    
08210    if (!dxp || !dxv || !dxa) {
08211       SUMA_SL_Err("Failed to find necessary objects"); SUMA_RETURN(NOPE);
08212    }
08213    
08214    /* sanity */
08215    SUMA_LH("Sanity checks");
08216    if (!dxa->data_format) {
08217       SUMA_SL_Err("Not a binary data file!");
08218       goto CLEAN_EXIT; 
08219    }
08220    if (!dxa->data) {
08221       SUMA_SL_Err("No data file!");
08222       goto CLEAN_EXIT; 
08223    }
08224    if (dxp->n_counts != 3) {
08225       SUMA_SL_Err("counts field must have 3 values");
08226       goto CLEAN_EXIT; 
08227    }
08228    if (dxp->n_delta != 9) {
08229       SUMA_SL_Err("delta must contain 9 elements!");
08230       goto CLEAN_EXIT; 
08231    }
08232    
08233    /* form the command */
08234    SUMA_LH("Forming command");
08235    /* 3d what? */
08236    chunk = 0;
08237    form[0] = '\0';
08238    data_type = SUMA_VarType2TypeCast(dxa->type);
08239    switch (data_type) {
08240       case SUMA_float:
08241          sprintf(form,"3Df");
08242          chunk = sizeof(float);
08243          break;
08244       case SUMA_double:
08245          sprintf(form,"3Dd");
08246          chunk = sizeof(double);
08247          break;
08248       case SUMA_int:
08249          sprintf(form,"3Di");
08250          chunk = sizeof(int);
08251          break;
08252       case SUMA_short:
08253          sprintf(form,"3Ds");
08254          chunk = sizeof(short);
08255          break;
08256       case SUMA_byte:
08257          sprintf(form,"3Db");
08258          chunk = sizeof(byte);
08259          break;
08260       default:
08261          SUMA_SL_Err("No support for this type");
08262          goto CLEAN_EXIT; 
08263          break;
08264    }
08265    /* byte ordering */
08266    SUMA_WHAT_ENDIAN(End);
08267    bs = 0;
08268    swp[0] = '\0';
08269    if (End != dxa->data_format) {
08270       SUMA_LH("swapping needed");
08271       bs = 1;
08272       switch (chunk) {
08273          case 1:
08274             break;
08275          case 2:
08276             sprintf(swp,"-2swap");
08277             break;
08278          case 4:
08279             sprintf(swp,"-4swap");
08280             break;
08281          case 8:
08282             sprintf(swp,"-8swap");
08283             break;
08284          default:
08285             SUMA_SL_Err("Patchunk!");
08286             break;
08287       }
08288    }
08289    if (dxa->data_off)  doff = (int)strtol(dxa->data_off,NULL, 10);
08290    else doff = 0;
08291    
08292    /* direction that varies the fastest (x) is in the last delta
08293       count is ordered like delta. I do not know about origin yet,
08294       I assume that origin follows the ordering of count
08295       see http://opendx.npaci.edu/docs/html/pages/usrgu068.htm 
08296       for reference, someday....*/
08297    
08298    /* number of voxels */
08299    LOAD_IVEC3( nxyz   , dxp->counts[2]    , dxp->counts[1]    , dxp->counts[0] ) ;
08300    
08301    /* orientation */
08302    /* find closest orientation in RAI, delta matrix does allow for obliqueness (non diagonal matrix) but we ignore it */
08303    LOAD_MAT(m33, 
08304                dxp->delta[6], dxp->delta[7], dxp->delta[8], 
08305                dxp->delta[3], dxp->delta[4], dxp->delta[5],
08306                dxp->delta[0], dxp->delta[1], dxp->delta[2] );
08307    orixyz = THD_matrix_to_orientation( m33 );
08308 
08309    /* dimensions */
08310    {  
08311       float fb[3]; 
08312       SUMA_NORM_VEC((&(dxp->delta[6])),3, fb[0]);
08313       SUMA_NORM_VEC((&(dxp->delta[3])),3, fb[1]);
08314       SUMA_NORM_VEC((&(dxp->delta[0])),3, fb[2]);
08315       LOAD_FVEC3( dxyz   , fb[0]    , fb[1]    , fb[2]    ) ;
08316       SUMA_sizeto3d_2_deltaHEAD(orixyz, &dxyz);
08317    }
08318    
08319    /* origin , assumed to be center of first voxel*/
08320    LOAD_FVEC3( orgxyz , dxp->origin[2]    , dxp->origin[1] , dxp->origin[0]  ) ;
08321    SUMA_originto3d_2_originHEAD(orixyz, &orgxyz);
08322     
08323    /* start point (edge of origin voxel) and end point (opposite to start ) */
08324    sp[0] = dxp->origin[2] + SUMA_ABS(dxyz.xyz[0]) / 2.0;
08325    sp[1] = dxp->origin[1] + SUMA_ABS(dxyz.xyz[1]) / 2.0;
08326    sp[2] = dxp->origin[0] + SUMA_ABS(dxyz.xyz[2]) / 2.0;
08327    ep[0] = dxp->origin[2] + (nxyz.ijk[0] - 0.5) * SUMA_ABS(dxyz.xyz[0]);
08328    ep[1] = dxp->origin[1] + (nxyz.ijk[1] - 0.5) * SUMA_ABS(dxyz.xyz[1]);
08329    ep[2] = dxp->origin[0] + (nxyz.ijk[2] - 0.5) * SUMA_ABS(dxyz.xyz[2]);
08330    SUMA_orcode_to_orstring (orixyz.ijk[0], orixyz.ijk[1], orixyz.ijk[2], orstr);
08331    sprintf(xfov," -xFOV %.2f%c-%.2f%c", sp[0], orstr[0], ep[0], orstr[3]);
08332    sprintf(yfov," -yFOV %.2f%c-%.2f%c", sp[1], orstr[1], ep[1], orstr[4]);
08333    sprintf(zfov," -zFOV %.2f%c-%.2f%c", sp[2], orstr[2], ep[2], orstr[5]);
08334   
08335    
08336    scom = (char *)SUMA_calloc((strlen(dxa->data)+500), sizeof(char));
08337    sprintf(scom,"to3d %s %s %s %s -prefix %s %s:%d:0:%d:%d:%d:%s ", swp, xfov, yfov, zfov, prefix, form, doff, dxp->counts[2], dxp->counts[1], dxp->counts[0], dxa->data);
08338    
08339    
08340    if (dset) { /* form the dset header */
08341          int nvals_read = 0;
08342          EDIT_dset_items( dset ,
08343                             ADN_prefix      , prefix ,
08344                             ADN_datum_all   , data_type ,
08345                             ADN_nxyz        , nxyz ,
08346                             ADN_xyzdel      , dxyz ,
08347                             ADN_xyzorg      , orgxyz ,
08348                             ADN_xyzorient   , orixyz ,
08349                             ADN_malloc_type , DATABLOCK_MEM_MALLOC ,
08350                             ADN_view_type   , VIEW_ORIGINAL_TYPE ,
08351                             ADN_type        , HEAD_ANAT_TYPE ,
08352                             ADN_func_type   , ANAT_BUCK_TYPE ,
08353                           ADN_none ) ;
08354 
08355          if (LoadData) {
08356             void *vec=NULL;
08357             if (!(vec = SUMA_BinarySuck(dxa->data, data_type, dxa->data_format, doff, -1, &nvals_read))) {
08358                SUMA_SL_Err("Failed to read data file"); goto CLEAN_EXIT;
08359             }
08360             EDIT_substitute_brick( dset , 0 , data_type , vec) ;      
08361             if (LocalHead) fprintf(SUMA_STDERR,"%s: Read %d values from file.\n", FuncName, nvals_read);
08362             /* DSET_write(dset) ; */
08363          }
08364    }
08365    
08366 
08367    
08368    CLEAN_EXIT:
08369    dxv = SUMA_Free_OpenDX_StructVec(dxv, iop);
08370    if (prefix) SUMA_free(prefix); prefix = NULL;
08371    
08372    SUMA_RETURN(scom);
08373 }

08391 {
08392    static char FuncName[]={"SUMA_OpenDX_Read_SO"};
08393    int i = 0, nf, iop;
08394    SUMA_OPEN_DX_STRUCT **dxv=NULL, *dxp=NULL, *dxc = NULL, *dxf = NULL, *dxo = NULL;
08395    SUMA_Boolean ans = NOPE;
08396    SUMA_Boolean LocalHead = NOPE;
08397    
08398    SUMA_ENTRY;
08399    
08400    if (!SO || !fname) {
08401       SUMA_SL_Err("NULL fname || NULL SO!");
08402       SUMA_RETURN(NOPE);
08403    }
08404    
08405    SUMA_LH("Reading objects");
08406    dxv = SUMA_OpenDX_Read(fname, &iop);
08407    if (!dxv) {
08408       SUMA_SL_Err("Failed to read DX file.");
08409       SUMA_RETURN(NOPE);
08410    }
08411    
08412    
08413    SUMA_LH("Checking for field object");
08414    dxf = SUMA_Find_OpenDX_Object_Class(dxv, iop, "field", &nf);
08415    if (!dxf || nf != 1) { SUMA_SL_Err("Failed to find one and only one field object"); goto CLEAN_EXIT; }
08416    /* get names of objects that contain positions and connections */
08417    dxp = dxc = dxo = NULL;   
08418    for (i=0; i<dxf->n_comp; ++i) {
08419       if (strstr(dxf->comp_name[i],"positions")) {
08420          dxp = SUMA_Find_OpenDX_Object_Name(dxv, iop, dxf->comp_value[i], &nf); 
08421          if (!dxp || nf != 1) { SUMA_SL_Err("Failed to find one and only one positions object"); goto CLEAN_EXIT; }
08422       }
08423       if (strstr(dxf->comp_name[i],"connections")) {
08424          dxc = SUMA_Find_OpenDX_Object_Name(dxv, iop, dxf->comp_value[i], &nf); 
08425          if (!dxc || nf != 1) { SUMA_SL_Err("Failed to find one and only one connections object"); goto CLEAN_EXIT; }
08426       }
08427       if (strstr(dxf->comp_name[i],"origin")) {
08428          dxo = SUMA_Find_OpenDX_Object_Name(dxv, iop, dxf->comp_value[i], &nf); 
08429          if (!dxo || nf != 1) { SUMA_SL_Err("Failed to find one and only one origin object.\nOrigin ignored"); }
08430       }
08431    }
08432    
08433    if (!dxp || !dxv) {
08434       SUMA_SL_Err("Failed to find necessary objects"); goto CLEAN_EXIT;
08435    }
08436    
08437    SUMA_LH("checking...");
08438    if (SUMA_VarType2TypeCast (dxp->type) != SUMA_float) {
08439       SUMA_SL_Err("Expected floats for positions"); goto CLEAN_EXIT;
08440    }
08441    if (dxp->bad_data) {
08442       SUMA_SL_Err("Problem reading data for positions"); goto CLEAN_EXIT;
08443    }
08444    if (dxp->rank != 1) {
08445       SUMA_SL_Err("Expected rank of 1 for positions"); goto CLEAN_EXIT;
08446    }
08447    if (dxp->shape != 3) {
08448       SUMA_SL_Err("Expected rank of 3 for positions"); goto CLEAN_EXIT;
08449    }
08450    if (SUMA_VarType2TypeCast (dxc->type) != SUMA_int) {
08451       SUMA_SL_Err("Expected ints for connections"); goto CLEAN_EXIT;
08452    }
08453    if (dxc->bad_data) {
08454       SUMA_SL_Err("Problem reading data for connections"); goto CLEAN_EXIT;
08455    }   
08456    if (dxc->rank != 1) {
08457       SUMA_SL_Err("Expected rank of 1 for connections"); goto CLEAN_EXIT;
08458    }
08459    if (dxc->shape != 3) {
08460       SUMA_SL_Err("Expected rank of 3 for connections"); goto CLEAN_EXIT;
08461    }
08462    /* if dxo */
08463    if (dxo) {
08464       if (SUMA_VarType2TypeCast (dxo->type) != SUMA_float) {
08465          SUMA_SL_Err("Expected floats for origin.\nOrigin ignored"); dxo = NULL;
08466       }
08467       if (!dxo->datap || dxo->shape * dxo->items != 3) {
08468          SUMA_SL_Err("Unknown origin format, ignoring origin"); dxo = NULL;
08469       }  
08470    }
08471    
08472    SUMA_LH("Take the gold");
08473    SO->FileType = SUMA_OPENDX_MESH;
08474    SO->FileFormat = SUMA_ASCII;
08475    
08476    SO->NodeDim = dxp->shape;
08477    SO->NodeList = (float *)dxp->datap; dxp->datap = NULL; /* datap will not be freed at end anymore */
08478    SO->N_Node = dxp->items;
08479    
08480    SO->FaceSetDim = dxc->shape;
08481    SO->FaceSetList = (int *)dxc->datap; dxc->datap = NULL; /* datap will not be freed at end anymore */
08482    SO->N_FaceSet = dxc->items;;
08483    SO->Name = SUMA_StripPath(fname);
08484    
08485    if (dxo) {
08486       float *fvec=(float*)dxo->datap;
08487       SUMA_LH("Adding origin");
08488       i = 0;
08489       while (i < dxp->items*dxp->shape) {
08490          SO->NodeList[i] += fvec[0]; ++i;
08491          SO->NodeList[i] += fvec[1]; ++i;
08492          SO->NodeList[i] += fvec[2]; ++i;
08493       }
08494    }
08495    
08496    /* all is well here */
08497    ans = YUP;
08498 
08499    CLEAN_EXIT:
08500    SUMA_LH("Frenching dxv");
08501    for (i=0; i<iop; ++i) {
08502       dxv[i] = SUMA_Free_OpenDX_Struct(dxv[i]);
08503    }
08504    if (dxv) SUMA_free(dxv); dxv = NULL;
08505    SUMA_RETURN(YUP);
08506 }

07569 {
07570    static char FuncName[]={"SUMA_OpenDX_Write"};
07571    
07572    SUMA_ENTRY;
07573    
07574    SUMA_SL_Err("Not supported yet");
07575    
07576    SUMA_RETURN(NOPE);
07577 }

02796 {
02797    static char FuncName[]={"SUMA_Ply_Read"};
02798    int i,j,k, j3, ji;
02799    PlyFile *ply = NULL;
02800    int nelems;
02801    char **elist = NULL;
02802    int file_type;
02803    float version;
02804    int nprops;
02805    int num_elems;
02806    PlyProperty **plist = NULL;
02807    Vertex **vlist = NULL;
02808    Face **flist = NULL;
02809    char *elem_name;
02810    int num_comments;
02811    char **comments = NULL;
02812    int num_obj_info;
02813    char **obj_info = NULL;
02814    SUMA_Boolean LocalHead = NOPE;
02815    
02816    SUMA_ENTRY;
02817 
02818    /* open a PLY file for reading */
02819    ply = ply_open_for_reading(f_name, &nelems, &elist, &file_type, &version);
02820    if (!ply) {
02821       fprintf (SUMA_STDERR, "Error %s: Failed to find/read %s.\n", FuncName, f_name);
02822       SUMA_RETURN (NOPE);
02823    }
02824    
02825    /* print what we found out about the file */
02826    if (LocalHead) fprintf (SUMA_STDERR, "%s: version %f\n", FuncName, version);
02827    if (LocalHead) fprintf (SUMA_STDERR, "%s: type %d\n", FuncName, file_type);
02828 
02829    /* go through each kind of element that we learned is in the file */
02830    /* and read them */
02831 
02832    for (i = 0; i < nelems; i++) {
02833 
02834     /* get the description of the first element */
02835     elem_name = elist[i];
02836     plist = ply_get_element_description (ply, elem_name, &num_elems, &nprops);
02837 
02838     /* print the name of the element, for debugging */
02839     if (LocalHead) fprintf (SUMA_STDERR, "%s: element %s %d\n", FuncName, elem_name, num_elems);
02840 
02841     /* if we're on vertex elements, read them in */
02842     if (equal_strings ("vertex", elem_name)) {
02843 
02844       /* create a vertex list to hold all the vertices */
02845       #ifdef USE_PLY_VERTEX
02846       vlist = (Vertex **) SUMA_malloc (sizeof (Vertex *) * num_elems);
02847       #endif
02848       
02849       SO->NodeList = (float *) SUMA_calloc (3*num_elems, sizeof(float));
02850       if (!SO->NodeList) {
02851          fprintf (SUMA_STDERR, "Error %s: Failed to allocate for SO->NodeList.\n", FuncName);
02852          SUMA_RETURN(NOPE);
02853       }
02854       
02855       /* set up for getting vertex elements */
02856 
02857       ply_get_property (ply, elem_name, &vert_props[0]);
02858       ply_get_property (ply, elem_name, &vert_props[1]);
02859       ply_get_property (ply, elem_name, &vert_props[2]);
02860       
02861       SO->NodeDim = 3;
02862       SO->N_Node = num_elems;
02863       /* grab all the vertex elements */
02864       for (j = 0; j < num_elems; j++) {
02865 
02866         /* grab and element from the file */
02867         #ifdef USE_PLY_VERTEX
02868         //vlist[j] = (Vertex *) SUMA_malloc (sizeof (Vertex));
02869         //ply_get_element (ply, (void *) vlist[j]);
02870         /* print out vertex x,y,z for debugging */
02871         if (LocalHead) fprintf (SUMA_STDERR, "%s vertex: %g %g %g\n", FuncName, vlist[j]->x, vlist[j]->y, vlist[j]->z);
02872         /* copy to NodeList */
02873         j3 = SO->NodeDim*j;
02874         SO->NodeList[j3] = vlist[j]->x;
02875         SO->NodeList[j3+1] = vlist[j]->y;
02876         SO->NodeList[j3+2] = vlist[j]->z;
02877         
02878         #else
02879         j3 = SO->NodeDim*j;
02880         ply_get_element (ply, (void *) &(SO->NodeList[j3]));
02881         /* print out vertex x,y,z for debugging */
02882         if (LocalHead) fprintf (SUMA_STDERR, "%s vertex: %g %g %g\n", FuncName, 
02883          SO->NodeList[j3], SO->NodeList[j3+1], SO->NodeList[j3+2]);
02884         #endif
02885          
02886       }
02887     }
02888 
02889     /* if we're on face elements, read them in */
02890     if (equal_strings ("face", elem_name)) {
02891 
02892       /* create a list to hold all the face elements */
02893       flist = (Face **) SUMA_malloc (sizeof (Face *) * num_elems);
02894 
02895       /* set up for getting face elements */
02896 
02897       ply_get_property (ply, elem_name, &face_props[0]);
02898       ply_get_property (ply, elem_name, &face_props[1]);
02899 
02900       /* grab all the face elements */
02901       for (j = 0; j < num_elems; j++) {
02902 
02903         /* grab and element from the file */
02904         flist[j] = (Face *) SUMA_malloc (sizeof (Face));
02905         ply_get_element (ply, (void *) flist[j]);
02906 
02907         /* print out face info, for debugging */
02908         if (LocalHead) {
02909          fprintf (SUMA_STDERR,"%s face: %d, list = ", FuncName, flist[j]->intensity);
02910          for (k = 0; k < flist[j]->nverts; k++)
02911             fprintf (SUMA_STDERR,"%d ", flist[j]->verts[k]);
02912          fprintf (SUMA_STDERR,"\n");
02913         }
02914         
02915       }
02916       /* copy face elements to SO structure */
02917       SO->FaceSetDim = flist[0]->nverts;
02918       SO->N_FaceSet = num_elems;
02919       SO->FaceSetList = (int *) SUMA_calloc (SO->FaceSetDim * num_elems, sizeof(int));
02920       if (!SO->FaceSetList) {
02921          fprintf (SUMA_STDERR, "Error %s: Failed to allocate for SO->NodeList.\n", FuncName);
02922          if (SO->NodeList) SUMA_free(SO->NodeList); 
02923          SUMA_RETURN(NOPE);
02924       }
02925       
02926       for (j = 0; j < num_elems; j++) {
02927          if (flist[j]->nverts != SO->FaceSetDim) {
02928             fprintf (SUMA_STDERR, "Error %s: All FaceSets must have the same dimension for SUMA.\n", FuncName);
02929             if (SO->NodeList) SUMA_free(SO->NodeList); 
02930             if (SO->FaceSetList) SUMA_free(SO->FaceSetList);
02931             SO->NodeList = NULL;
02932             SO->FaceSetList = NULL;
02933             SUMA_RETURN(NOPE);
02934          }
02935          ji = SO->FaceSetDim * j;
02936          for (k = 0; k < flist[j]->nverts; k++)
02937             SO->FaceSetList[ji+k] = flist[j]->verts[k];
02938       }
02939     }
02940 
02941    /* fill up a few more fields */
02942    SO->FileType = SUMA_PLY;
02943    if (file_type == PLY_ASCII) SO->FileFormat = SUMA_ASCII;
02944       else if (file_type == PLY_BINARY_BE) SO->FileFormat = SUMA_BINARY_BE;
02945          else if (file_type == PLY_BINARY_LE) SO->FileFormat = SUMA_BINARY_LE;
02946             else {
02947                fprintf (SUMA_STDERR, "Error %s: PLY_TYPE %d not recognized.\n", FuncName, file_type);
02948             }
02949             
02950    SO->Name = SUMA_StripPath(f_name);
02951    
02952    /* print out the properties we got, for debugging */
02953       if (LocalHead) {
02954          for (j = 0; j < nprops; j++)
02955             fprintf (SUMA_STDERR, "%s property %s\n", FuncName, plist[j]->name);
02956       }
02957    }
02958 
02959    /* grab and print out the comments in the file */
02960    comments = ply_get_comments (ply, &num_comments);
02961    if (LocalHead) {   
02962       for (i = 0; i < num_comments; i++)
02963          fprintf (SUMA_STDERR, "%s comment = '%s'\n", FuncName, comments[i]);
02964    }
02965    
02966    /* grab and print out the object information */
02967    obj_info = ply_get_obj_info (ply, &num_obj_info);
02968    if (LocalHead) {   
02969       for (i = 0; i < num_obj_info; i++)
02970          fprintf (SUMA_STDERR, "%s obj_info = '%s'\n", FuncName, obj_info[i]);
02971    }
02972    
02973    /* free the allocations necessary for vertex and facesetlists */
02974    for (j = 0; j < SO->N_FaceSet; j++) {
02975       SUMA_free(flist[j]);
02976    }
02977    SUMA_free(flist); flist = NULL;
02978    
02979    #ifdef USE_PLY_VERTEX
02980    for (j = 0; j < SO->N_Node; j++) {
02981       SUMA_free(vlist[j]);
02982    }
02983    SUMA_free(vlist); vlist = NULL;
02984    #endif
02985    /* close the PLY file, ply structure is freed within*/
02986    ply_close (ply);
02987    
02988    /* free plist */
02989    for (j = 0; j < nprops; j++) if (plist[j]) SUMA_free (plist[j]);
02990    if (plist) SUMA_free(plist);
02991    
02992    /* free comments */
02993    for (i = 0; i < num_comments; i++) if (comments[i]) SUMA_free (comments[i]);
02994    if (comments) SUMA_free (comments);
02995    
02996    /* free elist */
02997    for (i = 0; i < nelems; i++) if (elist[i]) SUMA_free (elist[i]);
02998    if (elist) SUMA_free (elist);
02999    
03000    /* free obj_info */
03001    for (i = 0; i < num_obj_info; i++) if (obj_info[i]) SUMA_free (obj_info[i]);
03002    if (obj_info) SUMA_free (obj_info);
03003     
03004    SUMA_RETURN(YUP);
03005 }