{ int ll = strlen(str) + strlen(error_list) + 16 ; \
     STATUS(str) ;                                    \
     error_list = (char*) XtRealloc( error_list , ll ) ;      \
     strcat( error_list , "*** ERROR:  ") ;           \
     strcat( error_list , str ) ; num_error++ ; }

{ int ll = strlen(str) + strlen(error_list) + 16 ; \
     STATUS(str) ;                                    \
     error_list = (char*)XtRealloc( error_list , ll ) ;      \
     strcat( error_list , str ) ; num_report++ ; }

"GPL AFNI: Analysis of Functional NeuroImages, by RW Cox (" COXEMAIL ")\n"    \
 "This is Version " VERSION               "\n\n"                               \
 " ** This software was designed to be used only for research purposes. **\n"  \
 " ** Clinical uses are not recommended, and have never been evaluated. **\n"  \
 " ** This software comes with no warranties of any kind whatsoever,    **\n"  \
 " ** and may not be useful for anything.  Use it at your own risk!     **\n"  \
 " ** If these terms are not acceptable, you aren't allowed to use AFNI.**\n"  \
 " ** See 'Define Datamode->Misc->License Info' for more details.       **\n\n"

do{ char *eee = getenv(nnn) ;                            \
                            if( eee != NULL ){                                   \
                              float val=strtod(eee,NULL); if(val>0.0) vvv = val; \
                            } } while(0)

do{ XtVaSetValues( (w) , XmNx,(int)(event->x_root),         \
                           XmNy,(int)(event->y_root), NULL ); \
      XMapRaised( XtDisplay(w) , XtWindow(w) ) ;              \
  } while(0)

(\
   LOAD_DIAG_MAT( twarp->warp[W_ ## xx ## yy ## zz].mfor ,      \
                  scale_ ## xx , scale_ ## yy , scale_ ## zz ) ,\
\
   LOAD_DIAG_MAT( twarp->warp[W_ ## xx ## yy ## zz].mbac ,                 \
           1.0 / scale_ ## xx , 1.0 / scale_ ## yy , 1.0 / scale_ ## zz ) ,\
\
   twarp->warp[W_ ## xx ## yy ## zz].bvec = bv_ ## yy , \
\
   twarp->warp[W_ ## xx ## yy ## zz].svec = sv_ ## yy , \
\
   LOAD_FVEC3( twarp->warp[W_ ## xx ## yy ## zz].bot ,   \
               bot_ ## xx , bot_ ## yy , bot_ ## zz   ) ,\
\
   LOAD_FVEC3( twarp->warp[W_ ## xx ## yy ## zz].top ,   \
               top_ ## xx , top_ ## yy , top_ ## zz   )  \
)

{ xdef = RWC_getname(display,nnn) ;        \
    if( xdef != NULL ){                      \
       fval = strtod( xdef , &cpt ) ;        \
       if( *cpt == '\0' && fval >= (bot) && fval <= (top) ) (fff) = fval ; } }

{ xdef = RWC_getname(display,nnn) ;        \
    if( xdef != NULL ){                      \
       ival = strtol( xdef , &cpt , 10 ) ;   \
       if( *cpt == '\0' && ival >= (bot) && ival <= (top) ) (iii) = ival ; } }

{ xdef = RWC_getname(display,nnn) ;        \
    if( xdef != NULL ) sss  = XtNewString(xdef) ; }

( (aa)=='R' ? ORI_R2L_TYPE : (aa)=='L' ? ORI_L2R_TYPE : \
    (aa)=='P' ? ORI_P2A_TYPE : (aa)=='A' ? ORI_A2P_TYPE : \
    (aa)=='I' ? ORI_I2S_TYPE : (aa)=='S' ? ORI_S2I_TYPE : ILLEGAL_TYPE )

10177 {
10178 ENTRY("AFNI_add_timeseries") ;
10179 
10180    if( tsim != NULL ){
10181       POPDOWN_timeseries_chooser ;
10182       ADDTO_IMARR(GLOBAL_library.timeseries,tsim) ;
10183    }
10184    EXRETURN ;
10185 }

07430 {
07431    THD_fvec3 new_fv ;
07432 
07433    if( warp == NULL ) return old_fv ;
07434 
07435    switch( warp->type ){
07436 
07437       default: new_fv = old_fv ; break ;
07438 
07439       case WARP_TALAIRACH_12_TYPE:{
07440          THD_linear_mapping map ;
07441          int iw ;
07442 
07443          /* test if input is in bot..top of each defined map */
07444 
07445          for( iw=0 ; iw < 12 ; iw++ ){
07446             map = warp->tal_12.warp[iw] ;
07447 
07448             if( old_fv.xyz[0] >= map.bot.xyz[0] &&
07449                 old_fv.xyz[1] >= map.bot.xyz[1] &&
07450                 old_fv.xyz[2] >= map.bot.xyz[2] &&
07451                 old_fv.xyz[0] <= map.top.xyz[0] &&
07452                 old_fv.xyz[1] <= map.top.xyz[1] &&
07453                 old_fv.xyz[2] <= map.top.xyz[2]   ) break ;  /* leave loop */
07454          }
07455          new_fv = MATVEC_SUB(map.mbac,old_fv,map.svec) ;
07456       }
07457       break ;
07458 
07459       case WARP_AFFINE_TYPE:{
07460          THD_linear_mapping map = warp->rig_bod.warp ;
07461          new_fv = MATVEC_SUB(map.mbac,old_fv,map.svec) ;
07462       }
07463       break ;
07464 
07465    }
07466    return new_fv ;
07467 }

01928 {
01929    MRI_IMAGE * im ;
01930    MCW_imseq_status * stat ;
01931    int i1,i2,jb,bb , dd1,dd2,tt1,tt2 ;
01932 
01933 ENTRY("AFNI_brick_to_mri") ;
01934 
01935 if(PRINT_TRACING){ char str[256] ; sprintf(str,"n=%d type=%d",n,type) ; STATUS(str) ; }
01936 
01937    /*-------------------------------------------------*/
01938    /*-------- May 1996: graph callbacks first --------*/
01939 
01940    if( type == graCR_getstatus ){
01941       MCW_grapher_status * grstat = myXtNew( MCW_grapher_status ) ;
01942 
01943       grstat->num_total  = grstat->num_series = br->dset->dblk->nvals ;
01944       grstat->nx         = br->n1 ;
01945       grstat->ny         = br->n2 ;
01946       grstat->nz         = br->n3 ;
01947 
01948       grstat->send_CB    = AFNI_gra_send_CB ;
01949       grstat->parent     = (XtPointer) br ;
01950       grstat->aux        = NULL ;
01951 
01952       grstat->transforms0D = & (GLOBAL_library.registered_0D) ;
01953       grstat->transforms1D = & (GLOBAL_library.registered_1D) ;
01954 
01955       strcpy( grstat->namecode , br->namecode ) ;
01956 
01957       RETURN( (XtPointer) grstat ) ;
01958    }
01959 
01960    if( type == graCR_getseries ){
01961       im = FD_brick_to_series( n , br ) ;
01962       RETURN( (XtPointer) im ) ;
01963    }
01964 
01965    /*----------------------------------------*/
01966    /*-------- Now do imseq callbacks --------*/
01967 
01968    if( n < 0 || n >= br->n3 ) RETURN(NULL) ;
01969 
01970    /*--- overlay # n ---*/
01971 
01972    if( type == isqCR_getoverlay  ){
01973       Three_D_View * im3d = (Three_D_View *) br->parent ;
01974 
01975 STATUS("get overlay") ;
01976 
01977       im = AFNI_overlay( n , br ) ;
01978       if( !AFNI_noenv("AFNI_VALUE_LABEL") ) AFNI_do_bkgd_lab( im3d ) ;
01979       RETURN( (XtPointer) im ) ;
01980    }
01981 
01982    /*--- status ---*/
01983 
01984    if( type == isqCR_getstatus ){
01985 
01986 STATUS("get status") ;
01987 
01988       stat = myXtNew( MCW_imseq_status ) ;
01989 
01990       stat->num_total  = br->n3 ;
01991       stat->num_series = br->n3 ;
01992       stat->send_CB    = AFNI_seq_send_CB ;
01993       stat->parent     = (XtPointer) br ;
01994       stat->aux        = NULL ;
01995 
01996       stat->transforms0D = & (GLOBAL_library.registered_0D) ;
01997       stat->transforms2D = & (GLOBAL_library.registered_2D) ;
01998       stat->slice_proj   = & (GLOBAL_library.registered_slice_proj) ;
01999 
02000       RETURN( (XtPointer) stat ) ;
02001    }
02002 
02003    /*--- 26 Feb 2001: return a memplot drawing struct ---*/
02004    /*--- 22 Mar 2002: add crosshairs to surface stuff ---*/
02005 
02006 #define RX 0.2
02007    if( type == isqCR_getmemplot ){
02008      Three_D_View *im3d = (Three_D_View *) br->parent ;
02009      int do_xhar=(im3d->vinfo->crosshair_visible && AFNI_yesenv("AFNI_CROSSHAIR_LINES"));
02010      int do_surf;
02011      MEM_plotdata *mp ;
02012      AFNI_surface_widgets *swid = im3d->vwid->view->swid ;  /* 19 Aug 2002 */
02013      THD_session *suss=im3d->ss_now ;                       /* 20 Jan 2004 */
02014      THD_dataxes *daxes=CURRENT_DAXES(br->dset) ;
02015 
02016      if( !IM3D_OPEN(im3d) )     RETURN(NULL) ;
02017 
02018      /* 20 Jan 2004: surfaces are now in the session, not on the dataset! */
02019 
02020      do_surf = SUMA_ENABLED && SESSION_HAS_SUMA(suss) ;
02021      if( !do_surf && !do_xhar ) RETURN(NULL) ;  /* nothing to do */
02022 
02023      /* get ready to plot */
02024 
02025 STATUS("creating memplot for image overlay") ;
02026      create_memplot_surely( "SUMA_plot" , 1.0 ) ;
02027      mp = get_active_memplot() ;
02028 
02029      /* plot surface stuff, if any */
02030 
02031     if( do_surf ){
02032      int ks ;
02033      int kbest=-1 , ibest=-1 ;          /* 24 Feb 2003 */
02034 
02035      AFNI_get_xhair_node( im3d , &kbest , &ibest ) ;   /* 24 Feb 2003 */
02036 
02037      for( ks=0 ; ks < suss->su_num ; ks++ ){  /* 14 Aug 2002: loop over surfaces */
02038       SUMA_surface *ag = suss->su_surf[ks] ;
02039       int nn , ii,jj ;
02040       SUMA_ixyz *nod ;
02041       THD_ivec3 iv,ivp,ivm ;
02042       THD_fvec3 fv,fvp,fvm ;
02043       float s1=1.0/br->n1 , s2=1.0/br->n2 , dxyz ;
02044       float rr_box=1.0,gg_box=0.0,bb_box=0.0 ;   /* white */
02045       float rr_lin=0.4,gg_lin=0.0,bb_lin=0.7 ;   /* dark blue */
02046       float rr_led=1.0,gg_led=0.0,bb_led=0.0 ;
02047       char str[32] , *eee ;
02048       float rx=RX ;         /* default rectangle halfsize */
02049       int   kkk=0 ;
02050       float xyz=0.0,xyzp,xyzm , rxm,rxp ;
02051       int skip_boxes=1 , skip_lines=0 , skip_lcen=0, skip_ledg=1 ;
02052       float boxsize=RX , linewidth=0.0 ;      /* 23 Feb 2003 */
02053       int firstb ;                            /* 23 Jan 2004 */
02054 
02055       if( ag == NULL ) continue ;             /* skip this non-existent one */
02056       nn = ag->num_ixyz ; nod = ag->ixyz ;
02057       if( nn < 1 || nod == NULL ) continue ;  /* nothing to do */
02058 
02059       /* define parameters for node boxes and triangle lines */
02060 
02061 STATUS("defining surface drawing parameters") ;
02062       if( swid != NULL && ks < swid->nrow ){     /* 19 Aug 2002: the new way */
02063         int cc, dd ;                             /*           to set colors: */
02064                                                  /* from the surface widgets */
02065 
02066         cc = MCW_val_bbox(swid->surf_bbox[ks]) ; /* 19 Feb 2003: skip it all? */
02067         if( cc == 0 ){
02068           skip_boxes = skip_lines = 1 ;
02069         } else {                                 /* see what is turned on */
02070           cc = swid->surf_node_av[ks]->ival ;
02071           skip_boxes = (cc == 0) ;
02072           if( !skip_boxes ){
02073             rr_box = DCOV_REDBYTE(im3d->dc,cc)   / 255.0 ;
02074             gg_box = DCOV_GREENBYTE(im3d->dc,cc) / 255.0 ;
02075             bb_box = DCOV_BLUEBYTE(im3d->dc,cc)  / 255.0 ;
02076           }
02077           cc = swid->surf_line_av[ks]->ival ;
02078           dd = swid->surf_ledg_av[ks]->ival ;             /* 26 Feb 2003 */
02079           skip_lcen  = (cc == 0) ;
02080           skip_ledg  = (dd == 0) ;
02081           skip_lines = (skip_lcen && skip_ledg) ;
02082           if( cc > 0 ){
02083             rr_lin = DCOV_REDBYTE(im3d->dc,cc)   / 255.0 ;
02084             gg_lin = DCOV_GREENBYTE(im3d->dc,cc) / 255.0 ;
02085             bb_lin = DCOV_BLUEBYTE(im3d->dc,cc)  / 255.0 ;
02086           }
02087           if( dd > 0 ){                                   /* 26 Feb 2003 */
02088             rr_led = DCOV_REDBYTE(im3d->dc,dd)   / 255.0 ;
02089             gg_led = DCOV_GREENBYTE(im3d->dc,dd) / 255.0 ;
02090             bb_led = DCOV_BLUEBYTE(im3d->dc,dd)  / 255.0 ;
02091           }
02092           boxsize   = swid->boxsize_av->ival   * 0.1   ;  /* 23 Feb 2003 */
02093           linewidth = swid->linewidth_av->ival * 0.002 ;
02094         }
02095 
02096       } else {                                   /* the old way    */
02097                                                  /* to set colors:  */
02098         eee = getenv("AFNI_SUMA_BOXCOLOR") ;     /* from environment */
02099         if( eee != NULL ){
02100           if( strcmp(eee,"none") == 0 || strcmp(eee,"skip") == 0 )
02101             skip_boxes = 1 ;                  /* don't do boxes */
02102           else
02103             DC_parse_color( im3d->dc , eee , &rr_box,&gg_box,&bb_box ) ;
02104         }
02105 
02106         eee = getenv("AFNI_SUMA_LINECOLOR") ;
02107         if( eee != NULL ){
02108           if( (strcmp(eee,"none")==0 || strcmp(eee,"skip")==0) )
02109             skip_lines = 1 ;
02110           else
02111             DC_parse_color( im3d->dc , eee , &rr_lin,&gg_lin,&bb_lin ) ;
02112         }
02113 
02114         eee = getenv("AFNI_SUMA_BOXSIZE") ;  /* maybe set boxsize? */
02115         if( eee != NULL ){
02116           float val=strtod(eee,NULL) ;
02117           if( val > 0.0 ) boxsize = val ;
02118         } else if( swid != NULL ){
02119           boxsize = swid->boxsize_av->ival * 0.1 ;
02120         }
02121 
02122         eee = getenv( "AFNI_SUMA_LINESIZE" ) ; /* maybe set linewidth? */
02123         if( eee != NULL ){
02124           float val = strtod(eee,NULL) ;
02125           if( val < 0.0 || val > 0.1 ) val = 0.0 ;
02126           linewidth = val ;
02127         } else if( swid != NULL ){
02128           linewidth = swid->linewidth_av->ival * 0.002 ;
02129         }
02130       }
02131 
02132       if( skip_boxes && skip_lines ) continue ; /* nothing to do? */
02133 
02134       /** 21 Mar 2002:
02135           We calculate plotting coordinates in "fdfind" coordinates,
02136           which are floating point indexes into the FD_brick.  However,
02137           these run from 0..n1-1 (in x), which are the centers of the
02138           voxels.  In turn these must be mapped to screen locations.
02139           For example, with n1=5, we have these voxels
02140 
02141               0   1   2   3   4    = index of voxel
02142             ---------------------
02143             |   |   |   |   |   |
02144             ---------------------
02145            0.0                 1.0 = screen coordinate (for memplot)
02146 
02147           Thus voxel index i maps to screen location (i+0.5)/n1.
02148           Previously, I forgot the +0.5, which didn't matter much,
02149           until the introduction of the image zoom feature last week. **/
02150 
02151       rx  = boxsize ;                /* 23 Feb 2003 */
02152       rxm = rx-0.5 ; rxp = rx+0.5 ;  /* The 0.5 voxel shift */
02153 
02154       /* find DICOM coordinates of next slice and previous slice */
02155 
02156       LOAD_IVEC3(iv,0,0,n+1) ;                     /* next */
02157       ivp = THD_fdind_to_3dind( br , iv ) ;
02158       fvp = THD_3dind_to_3dmm ( br->dset , ivp ) ;
02159       fvp = THD_3dmm_to_dicomm( br->dset , fvp ) ;
02160       LOAD_IVEC3(iv,0,0,n-1) ;                     /* previous */
02161       ivm = THD_fdind_to_3dind( br , iv ) ;
02162       fvm = THD_3dind_to_3dmm ( br->dset , ivm ) ;
02163       fvm = THD_3dmm_to_dicomm( br->dset , fvm ) ;
02164 
02165       /* threshold for determining which axis this slice is along */
02166 
02167       dxyz = MIN(br->del1,br->del2) ;
02168       dxyz = MIN(dxyz    ,br->del3) ; dxyz *= 0.1 ;
02169 
02170       set_color_memplot(rr_box,gg_box,bb_box) ;  /* box drawing colors */
02171       set_thick_memplot(0.0) ;
02172       firstb = 1 ;                               /* 23 Jan 2004 */
02173 
02174       /* find nodes inside this slice */
02175 
02176       if( skip_boxes ) STATUS("finding slice planes") ;
02177       else             STATUS("drawing node boxes") ;
02178 
02179       if( fabs(fvm.xyz[0]-fvp.xyz[0]) > dxyz ){               /* search x */
02180          float xb=fvm.xyz[0] , xt=fvp.xyz[0] , xm,xw ;        /* range of  */
02181          if( xb > xt ){ float t=xb ; xb=xt ; xt=t ; }         /* x in slice */
02182          xm = 0.5*(xb+xt); xw = 0.25*(xt-xb); xb = xm-xw; xt = xm+xw;
02183 STATUS(" - x plane") ;
02184          if( !skip_boxes ){
02185           for( ii=0 ; ii < nn ; ii++ ){
02186             if( nod[ii].x >= xb && nod[ii].x <= xt ){         /* inside?  */
02187                LOAD_FVEC3(fv,nod[ii].x,nod[ii].y,nod[ii].z) ; /* convert  */
02188                fv = THD_dicomm_to_3dmm( br->dset , fv ) ;     /* coords   */
02189                fv = THD_3dmm_to_3dfind( br->dset , fv ) ;     /* to slice */
02190                fv = THD_3dfind_to_fdfind( br , fv ) ;         /* indexes  */
02191 
02192                if( firstb ){
02193                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02194                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  );
02195                  firstb = 0 ;
02196                }
02197 
02198                plotrect_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02199                                  s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  ) ;
02200 
02201                if( ks == kbest && nod[ii].id == ibest ){   /* 24 Feb 2003 */
02202                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02203                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  );
02204                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]+rxp),
02205                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]-rxm)  );
02206                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]+0.5),
02207                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+0.5)  );
02208                  plotline_memplot( s1*(fv.xyz[0]+0.5), 1.0-s2*(fv.xyz[1]-rxm),
02209                                    s1*(fv.xyz[0]+0.5), 1.0-s2*(fv.xyz[1]+rxp)  );
02210                }
02211             }
02212           }
02213          }
02214          kkk = 0; xyz = xm; xyzp = xt; xyzm = xb;  /* for the triangles/lines below */
02215       }
02216       else if( fabs(fvm.xyz[1]-fvp.xyz[1]) > dxyz ){          /* search y */
02217          float yb=fvm.xyz[1] , yt=fvp.xyz[1] , ym,yw ;
02218          if( yb > yt ){ float t=yb ; yb=yt ; yt=t ; }
02219          ym = 0.5*(yb+yt); yw = 0.25*(yt-yb); yb = ym-yw; yt = ym+yw;
02220 STATUS(" - y plane") ;
02221          if( !skip_boxes ){
02222           for( ii=0 ; ii < nn ; ii++ ){
02223             if( nod[ii].y >= yb && nod[ii].y <= yt ){
02224                LOAD_FVEC3(fv,nod[ii].x,nod[ii].y,nod[ii].z) ;
02225                fv = THD_dicomm_to_3dmm( br->dset , fv ) ;
02226                fv = THD_3dmm_to_3dfind( br->dset , fv ) ;
02227                fv = THD_3dfind_to_fdfind( br , fv ) ;
02228 
02229                if( firstb ){
02230                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02231                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  );
02232                  firstb = 0 ;
02233                }
02234 
02235                plotrect_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02236                                  s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  ) ;
02237 
02238                if( ks == kbest && nod[ii].id == ibest ){   /* 24 Feb 2003 */
02239                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02240                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  );
02241                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]+rxp),
02242                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]-rxm)  );
02243                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]+0.5),
02244                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+0.5)  );
02245                  plotline_memplot( s1*(fv.xyz[0]+0.5), 1.0-s2*(fv.xyz[1]-rxm),
02246                                    s1*(fv.xyz[0]+0.5), 1.0-s2*(fv.xyz[1]+rxp)  );
02247                }
02248             }
02249           }
02250          }
02251          kkk = 1; xyz = ym; xyzp = yt; xyzm = yb;  /* for the triangles/lines below */
02252       }
02253       else if( fabs(fvm.xyz[2]-fvp.xyz[2]) > dxyz ){          /* search z */
02254          float zb=fvm.xyz[2] , zt=fvp.xyz[2] , zm,zw ;
02255          if( zb > zt ){ float t=zb ; zb=zt ; zt=t ; }
02256          zm = 0.5*(zb+zt); zw = 0.25*(zt-zb); zb = zm-zw; zt = zm+zw;
02257 STATUS(" - z plane") ;
02258          if( !skip_boxes ){
02259           for( ii=0 ; ii < nn ; ii++ ){
02260             if( nod[ii].z >= zb && nod[ii].z <= zt ){
02261                LOAD_FVEC3(fv,nod[ii].x,nod[ii].y,nod[ii].z) ;
02262                fv = THD_dicomm_to_3dmm( br->dset , fv ) ;
02263                fv = THD_3dmm_to_3dfind( br->dset , fv ) ;
02264                fv = THD_3dfind_to_fdfind( br , fv ) ;
02265 
02266                if( firstb ){
02267                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02268                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  );
02269                  firstb = 0 ;
02270                }
02271 
02272                plotrect_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02273                                  s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  ) ;
02274 
02275                if( ks == kbest && nod[ii].id == ibest ){   /* 24 Feb 2003 */
02276                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]-rxm),
02277                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+rxp)  );
02278                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]+rxp),
02279                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]-rxm)  );
02280                  plotline_memplot( s1*(fv.xyz[0]-rxm), 1.0-s2*(fv.xyz[1]+0.5),
02281                                    s1*(fv.xyz[0]+rxp), 1.0-s2*(fv.xyz[1]+0.5)  );
02282                  plotline_memplot( s1*(fv.xyz[0]+0.5), 1.0-s2*(fv.xyz[1]-rxm),
02283                                    s1*(fv.xyz[0]+0.5), 1.0-s2*(fv.xyz[1]+rxp)  );
02284                }
02285             }
02286           }
02287          }
02288          kkk = 2; xyz = zm; xyzp = zt; xyzm = zb;  /* for the triangles/lines below */
02289       }
02290 
02291       /* 10 Mar 2002:
02292          For each triangle that crosses the plane of the slice,
02293          plot a line segment at the intersection of the plane and triangle.
02294          The plane is along DICOM axis #kkk at coordinate xyz;
02295          these variables were set just above in the node display code. */
02296 
02297       if( !skip_lines && ag->num_ijk > 0 && ag->ijk != NULL ){
02298         SUMA_ijk *tr = ag->ijk ;        /* triangle list  */
02299         int      ntr = ag->num_ijk ;    /* number of triangles */
02300         int id,jd,kd ;
02301         THD_fvec3 fvijk[3] ;
02302         float ci,cj,ck , xlev ;
02303         int ilev ;
02304 
02305         for( ilev=0 ; ilev <= 2 ; ilev++ ){  /* 26 Feb 2003: loop over levels: */
02306                                              /* slice center, top & bot edges  */
02307           if( ilev == 0 ){
02308             if( skip_lcen ) continue ;  /* don't do center plane */
02309             xlev = xyz ;
02310             set_color_memplot(rr_lin,gg_lin,bb_lin) ;  /* line drawing colors */
02311             set_thick_memplot(linewidth) ;
02312           } else {
02313             if( skip_ledg ) continue ;  /* don't do edge planes */
02314             xlev = (ilev == 1) ? xyzp : xyzm ;
02315             set_color_memplot(rr_led,gg_led,bb_led) ;
02316             set_thick_memplot(0.0) ;
02317           }
02318 
02319 STATUS("drawing triangle lines") ;
02320 
02321           /* loop over triangles */
02322 
02323           for( ii=0 ; ii < ntr ; ii++ ){
02324 
02325             /* get indexes of triangle's nodes (from their id's) */
02326 
02327             id = SUMA_find_node_id(ag,tr[ii].id); if( id < 0 ) continue;
02328             jd = SUMA_find_node_id(ag,tr[ii].jd); if( jd < 0 ) continue;
02329             kd = SUMA_find_node_id(ag,tr[ii].kd); if( kd < 0 ) continue;
02330 
02331             /* load DICOM coords of triangle's nodes */
02332 
02333             LOAD_FVEC3(fvijk[0], nod[id].x, nod[id].y, nod[id].z) ;
02334             LOAD_FVEC3(fvijk[1], nod[jd].x, nod[jd].y, nod[jd].z) ;
02335             LOAD_FVEC3(fvijk[2], nod[kd].x, nod[kd].y, nod[kd].z) ;
02336 
02337             /* want 1 node on one size of plane, and 2 on the other */
02338 
02339             ci = fvijk[0].xyz[kkk] - xlev;      /* differences from center */
02340             cj = fvijk[1].xyz[kkk] - xlev;      /* of current slice plane */
02341             ck = fvijk[2].xyz[kkk] - xlev;
02342             jj = 4*(ci > 0.0) + 2*(cj > 0.0) + (ck > 0.0) ;
02343             if( jj == 0 || jj == 7 ) continue ; /* all have same sign */
02344 
02345             /* setup id,jd,kd so fvijk[id] is on one side of plane,
02346                and so that fvijk[jd] and fvijk[kd] are on other side */
02347 
02348             switch( jj ){
02349                case 6:
02350                case 1: id = 2 ; jd = 0 ; kd = 1 ; break ;  /* kd is the 1 */
02351                case 5:
02352                case 2: id = 1 ; jd = 0 ; kd = 2 ; break ;  /* jd is the 1 */
02353                case 4:
02354                case 3: id = 0 ; jd = 1 ; kd = 2 ; break ;  /* id is the 1 */
02355             }
02356 
02357             /* linearly interpolate between fvijk[id] and fvijk[jd]
02358                to find the point where this line hits the slice plane */
02359 
02360             ci = fvijk[id].xyz[kkk] - xlev;
02361             cj = fvijk[id].xyz[kkk] - fvijk[jd].xyz[kkk] ;
02362             if( cj == 0.0 ) continue ;            /* should not happen */
02363             ck = ci / cj ;
02364             if( ck < 0.0 || ck > 1.0 ) continue ; /* should not happen */
02365             cj = 1.0 - ck ;
02366             fvp = SCLADD_FVEC3(cj,fvijk[id],ck,fvijk[jd]) ;
02367 
02368             /* linearly interpolate between fvijk[id] and fvijk[kd] */
02369 
02370             cj = fvijk[id].xyz[kkk] - fvijk[kd].xyz[kkk] ;
02371             if( cj == 0.0 ) continue ;
02372             ck = ci / cj ;
02373             if( ck < 0.0 || ck > 1.0 ) continue ;
02374             cj = 1.0 - ck ;
02375             fvm = SCLADD_FVEC3(cj,fvijk[id],ck,fvijk[kd]) ;
02376 
02377             /* transform interpolated points to FD_brick coords */
02378 
02379             fvp = THD_dicomm_to_3dmm( br->dset , fvp ) ;
02380             if( fvp.xyz[0] < daxes->xxmin ||
02381                 fvp.xyz[0] > daxes->xxmax ||
02382                 fvp.xyz[1] < daxes->yymin ||
02383                 fvp.xyz[1] > daxes->yymax ||
02384                 fvp.xyz[2] < daxes->zzmin ||
02385                 fvp.xyz[2] > daxes->zzmax   ) continue ;  /* 08 Jan 2004 */
02386             fvp = THD_3dmm_to_3dfind( br->dset , fvp ) ;
02387             fvp = THD_3dfind_to_fdfind( br , fvp ) ;
02388 
02389             fvm = THD_dicomm_to_3dmm( br->dset , fvm ) ;
02390             if( fvm.xyz[0] < daxes->xxmin ||
02391                 fvm.xyz[0] > daxes->xxmax ||
02392                 fvm.xyz[1] < daxes->yymin ||
02393                 fvm.xyz[1] > daxes->yymax ||
02394                 fvm.xyz[2] < daxes->zzmin ||
02395                 fvm.xyz[2] > daxes->zzmax   ) continue ;  /* 08 Jan 2004 */
02396             fvm = THD_3dmm_to_3dfind( br->dset , fvm ) ;
02397             fvm = THD_3dfind_to_fdfind( br , fvm ) ;
02398 
02399             /* plot a line segment between them, in the plane of the slice */
02400             /* [21 Mar 2002: include the 0.5 shift mentioned way up above] */
02401 
02402             plotline_memplot( s1*(fvp.xyz[0]+0.5) , 1.0-s2*(fvp.xyz[1]+0.5) ,
02403                               s1*(fvm.xyz[0]+0.5) , 1.0-s2*(fvm.xyz[1]+0.5)  ) ;
02404 
02405           } /* end of loop over triangles */
02406           set_thick_memplot(0.0) ;              /* 15 Jan 2003 */
02407         } /* end of loop over levels: 26 Feb 2003 */
02408       } /* end of if over doing lines */
02409      } /* end of loop over surface index ks */
02410     } /* end of plotting surface stuff */
02411 
02412      /*----- put crosshairs on with lines, if desired -----*/
02413      /****** 22 Mar 2002: adapted from pixel overlay  ******/
02414 
02415      if( do_xhar ){
02416       MCW_grapher * grapher = UNDERLAY_TO_GRAPHER(im3d,br) ;
02417 
02418       THD_ivec3 ib = THD_3dind_to_fdind( br ,
02419                                          TEMP_IVEC3( im3d->vinfo->i1 ,
02420                                                      im3d->vinfo->j2 ,
02421                                                      im3d->vinfo->k3  ) ) ;
02422 STATUS("drawing crosshairs") ;
02423       set_thick_memplot(0.0) ;
02424 
02425       if( n == ib.ijk[2] || im3d->vinfo->xhairs_all ){
02426          int jp,ip , jcen,icen , gappp , jj,ii ;
02427          int idown,iup,iskip , jdown,jup,jskip , imon,jmon ;
02428          int a1 = br->a123.ijk[0] ,   /* x axis of the brick?    */
02429              ax = abs(a1) - 1       ; /* 0,1,2 for dataset x,y,z */
02430          int a2 = br->a123.ijk[1] ,   /* y axis of the brick?    */
02431              ay = abs(a2) - 1       ; /* 0,1,2 for dataset x,y,z */
02432          int a3 = br->a123.ijk[2] ,   /* z axis of the brick?    */
02433              az = abs(a3) - 1       ; /* 0,1,2 for dataset x,y,z */
02434 
02435          int gap,icr,jcr , nx=br->n1 , ny=br->n2 ;
02436 
02437          float rr,gg,bb ;             /* colors */
02438          float s1=1.0/br->n1 , s2=1.0/br->n2 ;  /* scale pixels to plot coords */
02439 #define PSX(i) (s1*((i)+0.5))
02440 #define PSY(j) (1.0-s2*((j)+0.5))
02441 
02442          /* spatial orientations of image axes */
02443 
02444          int ox = (ax==0) ? br->dset->daxes->xxorient :
02445                   (ax==1) ? br->dset->daxes->yyorient : br->dset->daxes->zzorient ;
02446 
02447          int oy = (ay==0) ? br->dset->daxes->xxorient :
02448                   (ay==1) ? br->dset->daxes->yyorient : br->dset->daxes->zzorient ;
02449 
02450          jp = im3d->vinfo->crosshair_ovcolor ;
02451          rr = DCOV_REDBYTE  (im3d->dc,jp) / 255.0 ;
02452          gg = DCOV_GREENBYTE(im3d->dc,jp) / 255.0 ;
02453          bb = DCOV_BLUEBYTE (im3d->dc,jp) / 255.0 ;
02454          set_color_memplot(rr,gg,bb) ;
02455 
02456          gap  = (grapher==NULL) ? im3d->vinfo->crosshair_gap : (grapher->mat+1)/2 ;
02457 
02458          icen = ib.ijk[0] ;  /* x-index of image pixel at focus */
02459          jcen = ib.ijk[1] ;  /* y-index */
02460 
02461          /** initialize montage steps **/
02462 
02463          if( im3d->vinfo->xhairs_show_montage ){           /* in "Multi" mode */
02464             iskip = im3d->vinfo->xhairs_nskip.ijk[ax] + 1 ;
02465             jskip = im3d->vinfo->xhairs_nskip.ijk[ay] + 1 ;
02466             if( a1 > 0 ){
02467                idown = im3d->vinfo->xhairs_ndown.ijk[ax] ;
02468                iup   = im3d->vinfo->xhairs_nup.ijk[ax] ;
02469             } else {
02470                iup   = im3d->vinfo->xhairs_ndown.ijk[ax] ;
02471                idown = im3d->vinfo->xhairs_nup.ijk[ax] ;
02472             }
02473             if( a2 > 0 ){
02474                jdown = im3d->vinfo->xhairs_ndown.ijk[ay] ;
02475                jup   = im3d->vinfo->xhairs_nup.ijk[ay] ;
02476             } else {
02477                jup   = im3d->vinfo->xhairs_ndown.ijk[ay] ;
02478                jdown = im3d->vinfo->xhairs_nup.ijk[ay] ;
02479             }
02480 
02481          } else {                                          /* in "Single" Mode */
02482            idown = iup = jdown = jup = iskip = jskip = 0 ;
02483            if( grapher != NULL ){ idown=-(iup+1); jdown=-(jup+1); } /* skip lines? */
02484          }
02485 
02486          /* draw vertical lines first */
02487 
02488          if( (im3d->vinfo->xhairs_orimask & (1<<oy)) != 0 ){
02489            for( imon=-idown ; imon <= iup ; imon++ ){
02490              icr = icen + imon * iskip ;
02491 
02492              if( im3d->vinfo->xhairs_periodic ){
02493                 while( icr < 0 )   icr += nx ;
02494                 while( icr >= nx ) icr -= nx ;
02495              } else {
02496                 if( icr < 0 || icr >= nx ) continue ;
02497              }
02498 
02499              gappp = (abs(icr-icen) <= gap) ? gap : -1 ; /* no gap if far from center */
02500 
02501              if( gappp < 0 ){  /* no gap => 1 vertical line */
02502 
02503                 plotline_memplot( PSX(icr) , 0.0 , PSX(icr) , 1.0 ) ;
02504 
02505              } else {          /* gap => 2 vertical lines */
02506 
02507                 jj = jcen-gappp-1 ;
02508                 if( jj >= 0 )
02509                   plotline_memplot( PSX(icr) , 1.0 , PSX(icr) , PSY(jj+0.5) ) ;
02510 
02511                 jj = jcen+gappp+1 ;
02512                 if( jj < ny )
02513                   plotline_memplot( PSX(icr) , PSY(jj-0.5) , PSX(icr) , 0.0 ) ;
02514              }
02515 
02516            }
02517          }
02518 
02519          /* draw horizontal lines */
02520 
02521          if( (im3d->vinfo->xhairs_orimask & (1<<ox)) != 0 ){  /* 31 Dec 1998 */
02522            for( jmon=-jdown ; jmon <= jup ; jmon++ ){
02523              jcr = jcen + jmon * jskip ;
02524              if( im3d->vinfo->xhairs_periodic ){
02525                 while( jcr < 0 )   jcr += ny ;
02526                 while( jcr >= ny ) jcr -= ny ;
02527              } else {
02528                 if( jcr < 0 || jcr >= ny ) continue ;
02529              }
02530 
02531              gappp = (abs(jcr-jcen) <= gap) ? gap : -1 ; /* no gap if far from center */
02532 
02533              if( gappp < 0 ){  /* no gap => 1 horizontal line */
02534 
02535                 plotline_memplot( 0.0 , PSY(jcr) , 1.0 , PSY(jcr) ) ;
02536 
02537              } else {          /* gap => 2 horizontal lines */
02538 
02539                 ii = icen-gappp-1 ;
02540                 if( ii >= 0 )
02541                   plotline_memplot( 0.0 , PSY(jcr) , PSX(ii+0.5) , PSY(jcr) ) ;
02542 
02543                 ii = icen+gappp+1 ;
02544                 if( ii < nx )
02545                   plotline_memplot( PSX(ii-0.5) , PSY(jcr) , 1.0 , PSY(jcr) ) ;
02546              }
02547            }
02548          }
02549 
02550          /* draw grapher frame, if needed */
02551 
02552          if( grapher != NULL ){
02553             int gs = gap , gb = (grapher->mat +2)/2 ;
02554 
02555             jcr = jcen ; icr = icen ;
02556 
02557             ip = icr - gb ; if( ip < 0   ) ip = 0 ;
02558             ii = icr + gs ; if( ii >= nx ) ii = nx-1 ;
02559 
02560             jp = jcr - gb ; if( jp <  0  ) jp = 0 ;
02561             jj = jcr + gs ; if( jj >= ny ) jj = ny-1 ;
02562 
02563             plotline_memplot( PSX(ip+0.5),PSY(jp+0.5) , PSX(ii-0.5),PSY(jp+0.5) ) ;
02564             plotline_memplot( PSX(ii-0.5),PSY(jp+0.5) , PSX(ii-0.5),PSY(jj-0.5) ) ;
02565             plotline_memplot( PSX(ii-0.5),PSY(jj-0.5) , PSX(ip+0.5),PSY(jj-0.5) ) ;
02566             plotline_memplot( PSX(ip+0.5),PSY(jj-0.5) , PSX(ip+0.5),PSY(jp+0.5) ) ;
02567 
02568          } /* end if "if grapher exists" */
02569 
02570       } /* end of "if correct slice" (or do all slices) */
02571      } /* end of crosshairs */
02572 
02573      /*----- return the completed plot -----*/
02574 
02575      if( MEMPLOT_NLINE(mp) < 1 ) DESTROY_MEMPLOT(mp) ;
02576 
02577      RETURN(mp) ; /* will be destroyed in imseq */
02578    }
02579 
02580    /*--- 20 Sep 2001: image label ---*/
02581 
02582    if( type == isqCR_getlabel ){
02583       Three_D_View * im3d = (Three_D_View *) br->parent ;
02584       char *lab , str[32] , *dd ;
02585       THD_ivec3 iv,ivp,ivm ;
02586       THD_fvec3 fv,fvp,fvm ;
02587       float dxyz , cc ;
02588       int ii ;
02589 
02590       if( im3d->type != AFNI_3DDATA_VIEW ) RETURN(NULL) ;
02591 
02592       LOAD_IVEC3(iv,0,0,n) ;
02593       ivp = THD_fdind_to_3dind( br , iv ) ;
02594       fvp = THD_3dind_to_3dmm ( br->dset , ivp ) ;
02595       fvp = THD_3dmm_to_dicomm( br->dset , fvp ) ;
02596 
02597       if( n == 0 ) LOAD_IVEC3(iv,0,0,1) ;
02598       else         LOAD_IVEC3(iv,0,0,n-1) ;
02599       ivm = THD_fdind_to_3dind( br , iv ) ;
02600       fvm = THD_3dind_to_3dmm ( br->dset , ivm ) ;
02601       fvm = THD_3dmm_to_dicomm( br->dset , fvm ) ;
02602 
02603       dxyz = MIN(br->del1,br->del2) ;
02604       dxyz = MIN(dxyz    ,br->del3) ; dxyz *= 0.1 ;
02605 
02606       if( fabs(fvm.xyz[0]-fvp.xyz[0]) > dxyz ){ /* +=R -=L */
02607          cc = fvp.xyz[0] ;
02608          dd = ( cc >= 0.0 ) ? "L" : "R" ;
02609       } else if( fabs(fvm.xyz[1]-fvp.xyz[1]) > dxyz ){ /* +=P -=A */
02610          cc = fvp.xyz[1] ;
02611          dd = ( cc >= 0.0 ) ? "P" : "A" ;
02612       } else if( fabs(fvm.xyz[2]-fvp.xyz[2]) > dxyz ){ /* +=S -=I */
02613          cc = fvp.xyz[2] ;
02614          dd = ( cc >= 0.0 ) ? "S" : "I" ;
02615       } else {
02616         RETURN(NULL) ;   /* should never happen */
02617       }
02618 
02619       sprintf(str,"%6.2f",fabs(cc)) ;
02620       for( ii=strlen(str)-1 ; ii > 0 && str[ii] == '0' ; ii-- ) str[ii] = '\0' ;
02621       if( str[ii] == '.' ) str[ii] = '\0' ;
02622       strcat(str,dd) ; lab = strdup(str) ; RETURN(lab) ;
02623    }
02624 
02625    /*--- underlay image # n ---*/
02626 
02627    if( type == isqCR_getimage || type == isqCR_getqimage ){
02628       Three_D_View * im3d = (Three_D_View *) br->parent ;
02629       int ival ;
02630 
02631       /*** decide which 3D brick to extract data from (ival) ***/
02632 
02633       if( EQUIV_DSETS(br->dset,im3d->anat_now) )      /* underlay dataset */
02634         ival = im3d->vinfo->anat_index ;
02635       else if( EQUIV_DSETS(br->dset,im3d->fim_now) )  /* overlay dataset */
02636         ival = im3d->vinfo->fim_index ;
02637       else
02638         ival = 0 ;                                    /* shouldn't happen */
02639 
02640            if( type == isqCR_getqimage      ) ival = -1 ; /* get empty image */
02641       else if( ival >= DSET_NVALS(br->dset) ) ival = br->dset->dblk->nvals -1 ;
02642 
02643 if(PRINT_TRACING)
02644 { char str[256] ;
02645   sprintf(str,"getting image n1=%d n2=%d ival=%d",br->n1,br->n2,ival) ;
02646   STATUS(str) ; }
02647 
02648       LOAD_DSET_VIEWS(im3d) ;  /* 02 Nov 1996 */
02649 
02650       im = FD_warp_to_mri( n , ival , br ) ; /* actually get image from dataset */
02651 
02652       if( ival < 0 ) RETURN( (XtPointer) im ) ;  /* return fake image */
02653 
02654       /* Load value of current pixel into display label */
02655       /* April 1996: only if image is at current slice  */
02656 
02657       { char buf[64] = "\0" ; int ibest=-1 ;
02658         AFNI_set_valabel( br , n , im , buf ) ;
02659         if( buf[0] != '\0' ){
02660           if( im3d->vinfo->underlay_type == UNDERLAY_ANAT )
02661             strcpy( im3d->vinfo->anat_val , buf ) ;
02662           else
02663             im3d->vinfo->anat_val[0] = '\0' ;
02664 
02665           if( !AFNI_noenv("AFNI_VALUE_LABEL") ) AFNI_do_bkgd_lab( im3d ) ;
02666 
02667           if( im->kind != MRI_complex && im->kind != MRI_rgb ){
02668             char qbuf[64] = "bg =" ;
02669             strcat(qbuf,buf) ; strcpy(buf,qbuf) ;
02670           }
02671           AFNI_get_xhair_node( im3d , NULL , &ibest ) ;   /* 21 Feb 2003 */
02672           if( ibest >= 0 ){
02673             char qbuf[64]; sprintf(qbuf,"\nxh = #%d",ibest); strcat(buf,qbuf);
02674           }
02675           MCW_set_widget_label( im3d->vwid->imag->pop_bkgd_lab , buf ) ;
02676           XtManageChild( im3d->vwid->imag->pop_bkgd_lab ) ;
02677         }
02678       }
02679 
02680       RETURN( (XtPointer) im ) ;
02681    }
02682 
02683 STATUS("get something else, but I don't care!") ;
02684 
02685    RETURN( NULL ) ;
02686 }

07296 {
07297    if( old_dset==NULL || new_dset==NULL  ) return 0 ;
07298 
07299    if( old_dset == new_dset->warp_parent ) return 1 ;
07300 
07301    if( old_dset->warp_parent == new_dset ) return 1 ;
07302 
07303    if( old_dset->warp_parent == new_dset->warp_parent &&
07304        old_dset->warp_parent != NULL                   ) return 1 ;
07305 
07306    if( new_dset->view_type   == VIEW_ORIGINAL_TYPE &&
07307        old_dset->view_type   != VIEW_ORIGINAL_TYPE &&
07308        old_dset->anat_parent != NULL               &&
07309        old_dset->anat_parent->warp_parent != NULL      ) return 1 ;
07310 
07311    if( old_dset->view_type   == VIEW_ORIGINAL_TYPE &&
07312        new_dset->view_type   != VIEW_ORIGINAL_TYPE &&
07313        new_dset->anat_parent != NULL               &&
07314        new_dset->anat_parent->warp_parent != NULL      ) return 1 ;
07315 
07316    return 0 ;
07317 }

04528 {
04529 ENTRY("AFNI_closedown_3dview") ;
04530 
04531    if( ! IM3D_VALID(im3d) ) EXRETURN ;
04532 
04533    /* Mar 1999: shutoff receivers, if any */
04534 
04535    AFNI_receive_destroy( im3d ) ;
04536 
04537    /* destroy any viewers attached */
04538 
04539    drive_MCW_imseq( im3d->s123 , isqDR_destroy , NULL ) ;
04540    drive_MCW_imseq( im3d->s231 , isqDR_destroy , NULL ) ;
04541    drive_MCW_imseq( im3d->s312 , isqDR_destroy , NULL ) ;
04542 
04543    drive_MCW_grapher( im3d->g123 , graDR_destroy , NULL ) ;
04544    drive_MCW_grapher( im3d->g231 , graDR_destroy , NULL ) ;
04545    drive_MCW_grapher( im3d->g312 , graDR_destroy , NULL ) ;
04546 
04547    /* erase FD bricks */
04548 
04549    myXtFree(im3d->b123_anat) ;
04550    myXtFree(im3d->b231_anat) ;
04551    myXtFree(im3d->b312_anat) ;
04552 
04553    myXtFree(im3d->b123_fim)  ;
04554    myXtFree(im3d->b231_fim)  ;
04555    myXtFree(im3d->b312_fim)  ;
04556 
04557    im3d->b123_ulay = im3d->b231_ulay = im3d->b312_ulay = NULL ;
04558 
04559    if( XtIsManaged(im3d->vwid->view->frame) == True )
04560       AFNI_controller_panel_CB( NULL , im3d , NULL ) ;
04561 
04562    /* null out montage info */
04563 
04564    LOAD_IVEC3(im3d->vinfo->xhairs_ndown,0,0,0) ;
04565    LOAD_IVEC3(im3d->vinfo->xhairs_nup  ,0,0,0) ;
04566    LOAD_IVEC3(im3d->vinfo->xhairs_nskip,0,0,0) ;
04567 
04568    /* de-fim */
04569 
04570    AFNI_fimmer_setref(im3d,NULL) ; CLEAR_FIMDATA(im3d) ;
04571 
04572    RESET_AFNI_QUIT(im3d) ;
04573 
04574    im3d->anat_now = im3d->fim_now = NULL ;
04575 
04576    AFNI_purge_unused_dsets() ;
04577 
04578    /* 19 Aug 2002: close surface widgets, too */
04579 
04580    if( im3d->vwid->view->swid != NULL )
04581      XtUnmapWidget( im3d->vwid->view->swid->wtop ) ;
04582 
04583    MPROBE ;
04584    EXRETURN ;
04585 }

04591 {
04592    Three_D_View * im3d = (Three_D_View *) cd ;
04593 
04594 ENTRY("AFNI_controller_panel_CB") ;
04595 
04596    if( ! IM3D_OPEN(im3d) || im3d->vwid->prog->panel_pb == NULL ) EXRETURN ;
04597 
04598    /** if view frame is open, close it and all its children **/
04599 
04600    if( XtIsManaged(im3d->vwid->view->frame) == True ){
04601 
04602       if( XtIsManaged(im3d->vwid->marks->frame) == True ){
04603          AFNI_marks_action_CB( NULL , (XtPointer) im3d , NULL ) ;
04604       }
04605 
04606       if( XtIsManaged(im3d->vwid->func->frame) ){
04607          CLOSE_PANEL(im3d,func) ;
04608       }
04609 
04610       if( XtIsManaged(im3d->vwid->dmode->frame) ){
04611          CLOSE_PANEL(im3d,dmode) ;
04612       }
04613 
04614       XtUnmanageChild(im3d->vwid->view->frame) ;
04615       if( im3d->vwid->prog->panel_pb_inverted ){
04616          MCW_invert_widget(im3d->vwid->prog->panel_pb) ;
04617          im3d->vwid->prog->panel_pb_inverted = False ;
04618       }
04619 
04620    } else {  /** open the view frame (but not its children) **/
04621 
04622       XtManageChild(im3d->vwid->view->frame) ;
04623       if( ! im3d->vwid->prog->panel_pb_inverted ){
04624          MCW_invert_widget(im3d->vwid->prog->panel_pb) ;
04625          im3d->vwid->prog->panel_pb_inverted = True ;
04626       }
04627    }
04628 
04629    RESET_AFNI_QUIT(im3d) ;
04630    EXRETURN ;
04631 }

09600 {
09601    int ibr , nvold , nvnew ;
09602    THD_statistics * stold , * stnew ;
09603 
09604 ENTRY("AFNI_copy_statistics") ;
09605 
09606    if( !ISVALID_3DIM_DATASET(dsold) || !ISVALID_3DIM_DATASET(dsnew) ) EXRETURN ;
09607 
09608    nvold = dsold->dblk->nvals ;
09609    nvnew = dsnew->dblk->nvals ;
09610    stold = dsold->stats ;
09611    stnew = dsnew->stats ;
09612    if( !ISVALID_STATISTIC(stold) ) EXRETURN ;
09613 
09614    if( stnew == NULL ){
09615       dsnew->stats  = stnew = myXtNew( THD_statistics ) ;
09616       stnew->type   = STATISTICS_TYPE ;
09617       stnew->nbstat = nvnew ;
09618       stnew->bstat  = (THD_brick_stats *)
09619                         XtMalloc( sizeof(THD_brick_stats) * nvnew ) ;
09620       ADDTO_KILL(dsnew->kl,stnew) ;
09621       stnew->parent = (XtPointer) dsnew ;
09622    } else {
09623       stnew->nbstat = nvnew ;
09624       stnew->bstat  = (THD_brick_stats *)
09625                         XtRealloc( (char *) stnew->bstat ,
09626                                    sizeof(THD_brick_stats) * nvnew ) ;
09627    }
09628 
09629    for( ibr=0 ; ibr < nvnew ; ibr++ ){
09630       if( ibr < nvold )
09631          stnew->bstat[ibr] = stold->bstat[ibr] ;
09632       else
09633          INVALIDATE_BSTAT(stnew->bstat[ibr]) ;
09634    }
09635 
09636    EXRETURN ;
09637 }

04747 {
04748    Three_D_View * im3d = (Three_D_View *) client_data ;
04749    int ipx = av->ival ;
04750 
04751 ENTRY("AFNI_crosshair_color_CB") ;
04752 
04753    if( ! IM3D_VALID(im3d) ) EXRETURN ;
04754 
04755    im3d->vinfo->crosshair_ovcolor = ipx ;
04756    if( im3d->vinfo->crosshair_visible ){
04757       AFNI_set_viewpoint( im3d , -1,-1,-1 , REDISPLAY_OVERLAY ) ;
04758    }
04759 
04760    RESET_AFNI_QUIT(im3d) ;
04761    EXRETURN ;
04762 }

07758 {
07759    Three_D_View *im3d = (Three_D_View *)cd ;
07760 
07761 ENTRY("AFNI_crosshair_EV") ;
07762 
07763    if( ! IM3D_OPEN(im3d) ) EXRETURN ;
07764 
07765    /*** handle events ***/
07766 
07767    switch( ev->type ){
07768 
07769      /*----- take button press -----*/
07770 
07771      case ButtonPress:{
07772        XButtonEvent *event = (XButtonEvent *)ev ;
07773 
07774        if( event->button == Button3 ||
07775            (event->button == Button1 &&
07776             (event->state & (ShiftMask|ControlMask))) ){
07777 
07778          im3d->vwid->butx = event->x_root ;  /* 17 May 2005 */
07779          im3d->vwid->buty = event->y_root ;
07780          event->button    = Button3 ;                                /* fake  */
07781          XmMenuPosition( im3d->vwid->imag->crosshair_menu , event ); /* where */
07782          XtManageChild ( im3d->vwid->imag->crosshair_menu ) ;        /* popup */
07783        }
07784 
07785        else {
07786          (void) MCW_popup_message( im3d->vwid->imag->crosshair_label ,
07787                                    " The road goes ever on and on\n"
07788                                    " Out from the door from where it began.\n"
07789                                    " Now, far ahead the road has gone\n"
07790                                    " And I must follow if I can.\n"
07791                                    " Pursuing it with eager feet\n"
07792                                    " Until it meets some other way\n"
07793                                    " Where many paths and errands meet\n"
07794                                    " And whither then I cannot say." ,
07795                                 MCW_USER_KILL | MCW_TIMER_KILL ) ;
07796        }
07797      }
07798      break ;
07799 
07800      /*----- take key press -----*/
07801 
07802 #if 0
07803      case KeyPress:{
07804        XKeyEvent * event = (XKeyEvent *) ev ;
07805        char           buf[32] ;
07806        KeySym         ks ;
07807        int            nbuf ;
07808 
07809        buf[0] = '\0' ;
07810        nbuf = XLookupString( event , buf , 32 , &ks , NULL ) ;
07811 
07812        switch( buf[0] ){
07813          default: break ;
07814        }
07815      }
07816      break ;
07817 #endif
07818    }
07819 
07820    EXRETURN ;
07821 }

04767 {
04768    Three_D_View * im3d = (Three_D_View *) client_data ;
04769    int ipx ;
04770 
04771 ENTRY("AFNI_crosshair_gap_CB") ;
04772 
04773    if( ! IM3D_VALID(im3d) ) EXRETURN ;
04774 
04775    if( av != NULL ){
04776       ipx = av->ival ;
04777    } else {
04778       if( im3d->vinfo->crosshair_gap_old > 0 ){
04779          ipx = im3d->vinfo->crosshair_gap_old ;
04780          im3d->vinfo->crosshair_gap_old = 0 ;
04781       } else {
04782          im3d->vinfo->crosshair_gap_old = im3d->vinfo->crosshair_gap ;
04783          ipx = 0 ;
04784       }
04785    }
04786 
04787    im3d->vinfo->crosshair_gap = ipx ;
04788    if( im3d->vinfo->crosshair_visible ){
04789       AFNI_set_viewpoint( im3d , -1,-1,-1 , REDISPLAY_OVERLAY ) ;
04790    }
04791 
04792    RESET_AFNI_QUIT(im3d) ;
04793    EXRETURN ;
04794 }

05959 {
05960    char buf[128] ;
05961    XmString xstr ;
05962    static char * RR="[R]" , * LL="[L]" ,
05963                * PP="[P]" , * AA="[A]" ,
05964                * SS="[S]" , * II="[I]" , * ZZ="   " ;
05965    char * xx , * yy , * zz ;
05966    float xval,yval,zval ;
05967 
05968 ENTRY("AFNI_crosshair_label") ;
05969 
05970    if( ! IM3D_VALID(im3d) ) RETURN( NULL );
05971 
05972    if( ! IM3D_OPEN(im3d) ){
05973 
05974       buf[0] = '\0' ;
05975       if( im3d->type != AFNI_IMAGES_VIEW ) strcat(buf," \n") ;
05976       strcat(buf, "1234567890123456789\n"
05977                   "1234567890123456789\n"
05978                   "1234567890123456789"  ) ;
05979 
05980    } else if( im3d->type == AFNI_IMAGES_VIEW || im3d->vinfo->show_voxind ){
05981 
05982 STATUS("voxel indexes") ;
05983 
05984       if( ISVALID_3DIM_DATASET(im3d->fim_now) &&
05985           im3d->vinfo->func_visible && DSET_INMEMORY(im3d->fim_now) ){
05986          THD_fvec3 fv ;
05987          THD_ivec3 iv ;
05988          int flag ;
05989 
05990          flag = im3d->fim_now->wod_flag ;
05991          im3d->fim_now->wod_flag = False ;
05992 
05993          fv = THD_dicomm_to_3dmm( im3d->fim_now ,
05994                                   TEMP_FVEC3(im3d->vinfo->xi,im3d->vinfo->yj,im3d->vinfo->zk) ) ;
05995          iv = THD_3dmm_to_3dind( im3d->fim_now , fv ) ;
05996 
05997          im3d->fim_now->wod_flag = flag ;
05998 
05999          sprintf( buf , "x: an=%4d fun=%4d\ny: an=%4d fun=%4d\nz: an=%4d fun=%4d" ,
06000                   im3d->vinfo->i1,iv.ijk[0] ,
06001                   im3d->vinfo->j2,iv.ijk[1] ,
06002                   im3d->vinfo->k3,iv.ijk[2]  ) ;
06003       } else {
06004          sprintf( buf , "voxel x = %4d\nvoxel y = %4d\nvoxel z = %4d" ,
06005                   im3d->vinfo->i1 , im3d->vinfo->j2 , im3d->vinfo->k3  ) ;
06006       }
06007    } else {
06008       char bxyz[3][32] , *cname ;
06009 
06010 STATUS("voxel coordinates") ;
06011 
06012       xval = im3d->vinfo->xi ;
06013       yval = im3d->vinfo->yj ;
06014       zval = im3d->vinfo->zk ;
06015 
06016       xx = (xval==0.0) ? (ZZ) : ( (xval<0.0) ? (RR) : (LL) ) ;
06017       yy = (yval==0.0) ? (ZZ) : ( (yval<0.0) ? (AA) : (PP) ) ;
06018       zz = (zval==0.0) ? (ZZ) : ( (zval<0.0) ? (II) : (SS) ) ;
06019 
06020       /** 16 July 1997 **/
06021 #if 1
06022       sprintf( bxyz[0] , "=%9.3f mm %s" ,
06023                GLOBAL_library.cord.xxsign * xval , xx ) ;
06024 
06025       sprintf( bxyz[1] , "=%9.3f mm %s" ,
06026                GLOBAL_library.cord.yysign * yval , yy ) ;
06027 
06028       sprintf( bxyz[2] , "=%9.3f mm %s" ,
06029                GLOBAL_library.cord.zzsign * zval , zz ) ;
06030 
06031       if( strcmp(GLOBAL_library.cord.orcode,"RAI") == 0 )
06032         cname = "=DICOM" ;
06033       else if( strcmp(GLOBAL_library.cord.orcode,"LPI") == 0 )
06034         cname = "=SPM  " ;
06035       else
06036         cname = "      " ;
06037 
06038       sprintf( buf , "[order: %s%s]\nx %17s\ny %17s\nz %17s"   ,
06039                GLOBAL_library.cord.orcode       , cname ,
06040                bxyz[GLOBAL_library.cord.first]  ,
06041                bxyz[GLOBAL_library.cord.second] ,
06042                bxyz[GLOBAL_library.cord.third]   ) ;
06043 #else
06044       sprintf( buf , "x =%9.3f mm %s\ny =%9.3f mm %s\nz =%9.3f mm %s" ,
06045                xval,xx , yval,yy , zval,zz ) ;
06046 #endif
06047    }
06048 
06049    xstr = XmStringCreateLtoR( buf , XmFONTLIST_DEFAULT_TAG ) ;
06050 
06051    RETURN( xstr ) ;
06052 }

07863 {
07864    Three_D_View *im3d = (Three_D_View *)client_data ;
07865    static char *cord_dicom="RAI" , *cord_spm="LPI" ;
07866    char *val=NULL ;
07867    int ii ;
07868 
07869 ENTRY("AFNI_crosshair_pop_CB") ;
07870 
07871         if( w == im3d->vwid->imag->crosshair_dicom_pb ) val = cord_dicom ;
07872    else if ( w == im3d->vwid->imag->crosshair_spm_pb  ) val = cord_spm   ;
07873 
07874    if( val != NULL && strcmp(GLOBAL_argopt.orient_code,val) != 0 ){
07875      POPDOWN_string_chooser ;   /* in case "Jumpto xyz" is open */
07876      MCW_strncpy(GLOBAL_argopt.orient_code,val,4) ;
07877      THD_coorder_fill( GLOBAL_argopt.orient_code , &GLOBAL_library.cord ) ;
07878      for( ii=0 ; ii < MAX_CONTROLLERS ; ii++ )
07879        AFNI_crosshair_relabel( GLOBAL_library.controllers[ii] ) ;
07880    }
07881    EXRETURN ;
07882 }

07828 {
07829    XmString xstr ;
07830    Boolean same ;
07831 
07832 ENTRY("AFNI_crosshair_relabel") ;
07833 
07834    if( !IM3D_OPEN(im3d) ) EXRETURN ;
07835    xstr = AFNI_crosshair_label( im3d ) ; if( xstr == NULL ) EXRETURN ;
07836    if( im3d->vinfo->old_crosshair_label == (XmString)NULL ) /* shouldn't */
07837      same = False ;                                         /* happen   */
07838    else
07839      same = XmStringCompare( xstr , im3d->vinfo->old_crosshair_label ) ;
07840 
07841    if( same == False ){
07842       XtVaSetValues( im3d->vwid->imag->crosshair_label ,       /* redisplay */
07843                         XmNlabelString , xstr ,                /* if changed */
07844                      NULL ) ;
07845       MCW_expose_widget( im3d->vwid->imag->crosshair_label ) ; /* redraw now! */
07846       if( im3d->vinfo->old_crosshair_label != (XmString)NULL )
07847         XmStringFree(im3d->vinfo->old_crosshair_label) ;       /* toss old */
07848       im3d->vinfo->old_crosshair_label = xstr ;                /* new old */
07849    } else {
07850       XmStringFree( xstr ) ;  /* was same --> don't need this copy */
07851    }
07852 
07853    EXRETURN ;
07854 }

04638 {
04639    Three_D_View * im3d = (Three_D_View *) client_data ;
04640    int val , omold ;
04641 
04642 ENTRY("AFNI_crosshair_visible_CB") ;
04643 
04644    if( ! IM3D_VALID(im3d) ) EXRETURN ;
04645 
04646    if( av->ival == av->old_ival ) EXRETURN ;
04647 
04648    switch( av->ival ){
04649       case AFNI_XHAIRS_OFF:
04650          im3d->vinfo->crosshair_visible   = False ;
04651          im3d->vinfo->xhairs_show_montage = False ;
04652       break ;
04653 
04654       case AFNI_XHAIRS_SINGLE:
04655          im3d->vinfo->crosshair_visible   = True ;
04656          im3d->vinfo->xhairs_show_montage = False ;
04657       break ;
04658 
04659       default:                                     /* 31 Dec 1998:  */
04660       case AFNI_XHAIRS_MULTI:                      /*   new options */
04661          im3d->vinfo->crosshair_visible   = True ; /*   like Multi  */
04662          im3d->vinfo->xhairs_show_montage = True ;
04663       break ;
04664    }
04665 
04666    /* 31 Dec 1998: only allow crosshairs of some orientations */
04667 
04668    omold = im3d->vinfo->xhairs_orimask ;  /* 02 Jun 1999 */
04669 
04670    switch( av->ival ){
04671       default:                im3d->vinfo->xhairs_orimask = ORIMASK_ALL  ; break;
04672       case AFNI_XHAIRS_LR_AP: im3d->vinfo->xhairs_orimask = ORIMASK_LR_AP; break;
04673       case AFNI_XHAIRS_LR_IS: im3d->vinfo->xhairs_orimask = ORIMASK_LR_IS; break;
04674       case AFNI_XHAIRS_AP_IS: im3d->vinfo->xhairs_orimask = ORIMASK_AP_IS; break;
04675       case AFNI_XHAIRS_LR:    im3d->vinfo->xhairs_orimask = ORIMASK_LR   ; break;
04676       case AFNI_XHAIRS_AP:    im3d->vinfo->xhairs_orimask = ORIMASK_AP   ; break;
04677       case AFNI_XHAIRS_IS:    im3d->vinfo->xhairs_orimask = ORIMASK_IS   ; break;
04678    }
04679 
04680    AFNI_set_viewpoint( im3d , -1,-1,-1 , REDISPLAY_OVERLAY ) ;
04681 
04682    /* 02 Jun 1999: if xhairs layout has changed, send a notice */
04683 
04684    if( omold != im3d->vinfo->xhairs_orimask ) AFNI_process_viewpoint( im3d ) ;
04685 
04686    RESET_AFNI_QUIT(im3d) ;
04687    EXRETURN ;
04688 }

07489 {
07490    Three_D_View * im3d = (Three_D_View *) client_data ;
07491    int vwarp ;
07492 
07493 ENTRY("AFNI_define_CB") ;
07494 
07495    if( ! IM3D_VALID(im3d) ) EXRETURN ;
07496 
07497    /*-----  define marks panel -----*/
07498 
07499    if( w == im3d->vwid->view->define_marks_pb ){
07500 
07501       AFNI_viewing_widgets  * view  = im3d->vwid->view  ;
07502       AFNI_marks_widgets    * marks = im3d->vwid->marks ;
07503 
07504       if( XtIsManaged(marks->frame) == True ){  /* close it down */
07505 
07506 STATUS("closing marks") ;
07507 
07508          AFNI_marks_action_CB( NULL , (XtPointer) im3d , NULL ) ;
07509 
07510       } else {                                  /* open it up */
07511 
07512 STATUS("opening marks") ;
07513 
07514          marks->old_visible = marks->ov_visible ;
07515          marks->ov_visible  = True ;
07516          marks->changed     = False ;  /* not changed yet! */
07517 
07518          MCW_set_bbox( marks->edits_bbox , 0 ) ;
07519          AFNI_marks_edits_CB( NULL , (XtPointer) im3d , NULL ) ;
07520 
07521          MCW_set_bbox( view->see_marks_bbox , 1 ) ;
07522          if( marks->old_visible != marks->ov_visible )
07523             AFNI_see_marks_CB( NULL , (XtPointer) im3d , NULL ) ;
07524 
07525          /* Oct 1998: turn off some controls if no markers present */
07526 
07527          if( im3d->anat_now->markers == NULL ){
07528             SENSITIZE( marks->edits_bbox->wrowcol , False ) ;
07529             SENSITIZE( marks->tlrc_big_bbox->wrowcol , False ) ;
07530             AV_SENSITIZE( marks->disp_scolor_av , False ) ;
07531             AV_SENSITIZE( marks->disp_size_av   , False ) ;
07532             AV_SENSITIZE( marks->disp_gap_av    , False ) ;
07533             SENSITIZE( marks->action_rowcol , False ) ;
07534             SENSITIZE( marks->transform_pb , False ) ;
07535          } else {
07536             vwarp = WARPED_VIEW(im3d->vinfo->view_type) ;
07537             SENSITIZE( marks->edits_bbox->wrowcol ,
07538                             (Boolean) ISVALID_VIEW(vwarp) ) ;
07539             SENSITIZE( marks->tlrc_big_bbox->wrowcol ,
07540                        (Boolean) (vwarp==VIEW_TALAIRACH_TYPE) ) ;
07541             AV_SENSITIZE( marks->disp_scolor_av , True ) ;
07542             AV_SENSITIZE( marks->disp_size_av   , True ) ;
07543             AV_SENSITIZE( marks->disp_gap_av    , True ) ;
07544             SENSITIZE( marks->action_rowcol , True ) ;
07545          }
07546 
07547    /*** I don't know why this is needed, but it prevents the
07548         marks panels geometry from getting screwed up, so it's here ***/
07549 
07550 #ifndef USING_LESSTIF
07551 #define REMANAGE_MARKS 1
07552 #else
07553 #define REMANAGE_MARKS 0
07554 #endif
07555 
07556 #if 1
07557        { static int first=1 ;
07558          if( REMANAGE_MARKS || first ){               /* CYGWIN: must do 1st time in */
07559            XtUnmanageChild( marks->rowcol ) ;         /* but not on later times --   */
07560            XtUnmanageChild( marks->tog_rowcol ) ;     /* probably a LessTif bug      */
07561            XtUnmanageChild( marks->control_rowcol ) ;
07562            XtUnmanageChild( marks->control_frame ) ;
07563            XtUnmanageChild( marks->tog_frame ) ;
07564            first = 0 ;
07565          }
07566        }
07567 #endif
07568 
07569          OPEN_PANEL(im3d,marks) ;
07570 
07571 #if 1
07572 #if 0
07573          XFlush( XtDisplay(marks->rowcol) ) ; XSync( XtDisplay(marks->rowcol),False ) ;
07574 #endif
07575          if( im3d->anat_now->markers != NULL ){  /* Oct 1998 */
07576             XtManageChild( marks->tog_rowcol ) ;
07577             XtManageChild( marks->tog_frame ) ;
07578          }
07579          XtManageChild( marks->control_rowcol ) ;
07580          XtManageChild( marks->control_frame ) ;
07581          XtManageChild( marks->rowcol ) ;
07582 #endif
07583 
07584       /* redraw markers if not visible already (if there are any to redraw) */
07585 
07586          if( marks->old_visible != True &&
07587              im3d->anat_now->markers != NULL &&
07588              im3d->anat_now->markers->numset > 0 )
07589 
07590             AFNI_set_viewpoint( im3d , -1,-1,-1 , REDISPLAY_OVERLAY ) ;
07591       }
07592 
07593       EXRETURN ;
07594    }
07595 
07596    /*----- define function panel -----*/
07597 
07598    if( w == im3d->vwid->view->define_func_pb ){
07599       AFNI_viewing_widgets  * view  = im3d->vwid->view  ;
07600       AFNI_function_widgets * func  = im3d->vwid->func ;
07601 
07602       if( XtIsManaged(func->frame) ){
07603 
07604 STATUS("closing function") ;
07605 
07606          CLOSE_PANEL(im3d,func) ;
07607       } else {
07608 
07609 STATUS("opening function" ) ;
07610 
07611 #ifndef USING_LESSTIF
07612 #define REMANAGE_FUNC
07613 #endif
07614 
07615 #ifdef REMANAGE_FUNC
07616 STATUS("unmanaging children") ;
07617          XtUnmanageChild( im3d->vwid->func->rowcol ) ;
07618          XtUnmanageChild( im3d->vwid->func->thr_rowcol ) ;
07619          XtUnmanageChild( im3d->vwid->func->inten_rowcol ) ;
07620          XtUnmanageChild( im3d->vwid->func->options_rowcol ) ;
07621 #endif
07622 
07623 STATUS("opening panel") ;
07624          OPEN_PANEL(im3d,func) ;
07625 
07626 #ifdef REMANAGE_FUNC
07627 STATUS("remanaging children") ;
07628          XtManageChild( im3d->vwid->func->thr_rowcol ) ;
07629          XtManageChild( im3d->vwid->func->inten_rowcol ) ;
07630          XtManageChild( im3d->vwid->func->options_rowcol ) ;
07631          XtManageChild( im3d->vwid->func->rowcol ) ;
07632 #endif
07633          HIDE_SCALE(im3d) ;
07634          update_MCW_pbar( im3d->vwid->func->inten_pbar ) ;
07635          FIX_SCALE_SIZE(im3d) ; FIX_SCALE_VALUE(im3d) ;
07636 
07637 #ifdef FIX_SCALE_SIZE_LATER
07638         (void) XtAppAddTimeOut( MAIN_app,50,fixscale,im3d ) ; /* 09 May 2001 */
07639 #endif
07640 
07641 /***     XtManageChild( im3d->vwid->func->inten_bbox->wrowcol ) ; ***/
07642       }
07643 
07644       EXRETURN ;
07645    }
07646 
07647    /*-- define datamode panel --*/
07648 
07649    if( w == im3d->vwid->view->define_dmode_pb ){
07650       AFNI_viewing_widgets  * view  = im3d->vwid->view  ;
07651       AFNI_datamode_widgets * dmode = im3d->vwid->dmode ;
07652 
07653       if( XtIsManaged(dmode->frame) ){
07654 
07655 STATUS("closing dmode") ;
07656 
07657          CLOSE_PANEL(im3d,dmode) ;
07658       } else {
07659 
07660 STATUS("opening dmode" ) ;
07661 
07662          OPEN_PANEL(im3d,dmode) ;
07663       }
07664 
07665       EXRETURN ;
07666    }
07667 
07668    RESET_AFNI_QUIT(im3d) ;
07669    EXRETURN ;
07670 }

05231 {
05232    char str[256] ;
05233 
05234    if( !IM3D_OPEN(im3d) || !im3d->vwid->imag->do_bkgd_lab ) return ;
05235 
05236 #define VSTR(x) ( ((x)[0] == '\0') ? ("?") : (x) )
05237 
05238    sprintf(str,"ULay = %s\n"
05239                "OLay = %s\n"
05240                "Thr  = %s" ,
05241            VSTR(im3d->vinfo->anat_val),
05242            VSTR(im3d->vinfo->func_val),
05243            VSTR(im3d->vinfo->thr_val ) ) ;
05244 
05245 #undef VSTR
05246 
05247    MCW_set_widget_label( im3d->vwid->func->bkgd_lab , str ) ;
05248    XtManageChild( im3d->vwid->func->bkgd_lab ) ;
05249    FIX_SCALE_SIZE(im3d) ;
05250 }

06750 {
06751    THD_warp *swarp = NULL ;
06752    char idkey[256] ;
06753 
06754    if( GLOBAL_library.warptable == NULL ||
06755        dset_to   == NULL                ||
06756        dset_from == NULL                  ) return NULL ;
06757 
06758    sprintf(idkey,"%s,%s",dset_to->idcode.str,dset_from->idcode.str) ;
06759    swarp = (THD_warp *) findin_Htable( idkey , GLOBAL_library.warptable ) ;
06760    return swarp ;
06761 }

06140 {
06141    int ib ;
06142 
06143 ENTRY("AFNI_first_tog") ;
06144 
06145    for( ib=0 ; ib < ntog ; ib++ )
06146       if( XmToggleButtonGetState(tog[ib]) ) break ;
06147 
06148    if( ib >= ntog ) ib = -1 ;
06149    RETURN(ib) ;
06150 }

07385 {
07386    THD_fvec3 new_fv ;
07387 
07388    if( warp == NULL ) return old_fv ;
07389 
07390    switch( warp->type ){
07391 
07392       default: new_fv = old_fv ; break ;
07393 
07394       case WARP_TALAIRACH_12_TYPE:{
07395          THD_linear_mapping map ;
07396          int iw ;
07397 
07398          /* forward transform each possible case,
07399             and test if result is in bot..top of defined map */
07400 
07401          for( iw=0 ; iw < 12 ; iw++ ){
07402             map    = warp->tal_12.warp[iw] ;
07403             new_fv = MATVEC_SUB(map.mfor,old_fv,map.bvec) ;
07404 
07405             if( new_fv.xyz[0] >= map.bot.xyz[0] &&
07406                 new_fv.xyz[1] >= map.bot.xyz[1] &&
07407                 new_fv.xyz[2] >= map.bot.xyz[2] &&
07408                 new_fv.xyz[0] <= map.top.xyz[0] &&
07409                 new_fv.xyz[1] <= map.top.xyz[1] &&
07410                 new_fv.xyz[2] <= map.top.xyz[2]   ) break ;  /* leave loop */
07411          }
07412       }
07413       break ;
07414 
07415       case WARP_AFFINE_TYPE:{
07416          THD_linear_mapping map = warp->rig_bod.warp ;
07417          new_fv = MATVEC_SUB(map.mfor,old_fv,map.bvec) ;
07418       }
07419       break ;
07420 
07421    }
07422    return new_fv ;
07423 }

03455 {
03456    Three_D_View *im3d = (Three_D_View *)grapher->parent ;
03457 
03458 ENTRY("AFNI_gra_send_CB") ;
03459 
03460 if(PRINT_TRACING)
03461 { char str[256] ; sprintf(str,"reason=%d",cbs->reason) ; STATUS(str) ; }
03462 
03463    if( ! IM3D_VALID(im3d) ||
03464        (im3d->ignore_seq_callbacks==AFNI_IGNORE_EVERYTHING) ) EXRETURN ;
03465 
03466    switch( cbs->reason ){
03467 
03468       default: break ;  /* unimplemented reasons */
03469 
03470       /*** Death ***/
03471 
03472       case graCR_destroy:{
03473          MCW_grapher * gxyz = im3d->g123 ,
03474                      * gyzx = im3d->g231 ,
03475                      * gzxy = im3d->g312  ;
03476          MCW_imseq * seq = GRAPHER_TO_VIEWER(im3d,grapher) ;
03477          Widget w ;
03478 
03479               if( grapher == gxyz ){
03480                  w = im3d->vwid->imag->graph_xyz_pb ; im3d->g123 = NULL ;
03481                  STATUS("destruction of g123") ;
03482          }
03483          else if( grapher == gyzx ){
03484                  w = im3d->vwid->imag->graph_yzx_pb ; im3d->g231 = NULL ;
03485                  STATUS("destruction of g231") ;
03486          }
03487          else if( grapher == gzxy ){
03488                  w = im3d->vwid->imag->graph_zxy_pb ; im3d->g312 = NULL ;
03489                  STATUS("destruction of g312") ;
03490          }
03491          else
03492                  EXRETURN ;  /* something goofy happened? */
03493 
03494          myXtFree( grapher->status ) ;  /* 08 Mar 1999: via mcw_malloc.c */
03495          myXtFree( grapher ) ;          /* free the data space */
03496          MCW_invert_widget(w) ;         /* back to normal */
03497          NORMAL_cursorize(w) ;          /* 20 Jul 2005 */
03498 
03499          /* redisplay the crosshairs, if needed */
03500 
03501          if( seq != NULL && im3d->vinfo->crosshair_visible==True &&
03502              im3d->ignore_seq_callbacks == AFNI_IGNORE_NOTHING     )
03503 
03504             drive_MCW_imseq( seq , isqDR_overlay , (XtPointer) -1 ) ;
03505       }
03506       MPROBE ;
03507       break ;  /* end of destroy */
03508 
03509       /*** User sets new location ***/
03510 
03511       case graCR_newxyzm:{
03512          THD_ivec3 id ;
03513 
03514          if( cbs->xcen >= 0 && cbs->xcen < br->n1 &&
03515              cbs->ycen >= 0 && cbs->ycen < br->n2 &&
03516              cbs->zcen >= 0 && cbs->zcen < br->n3   ){
03517 
03518             id = THD_fdind_to_3dind(
03519                     br , TEMP_IVEC3(cbs->xcen,cbs->ycen,cbs->zcen) );
03520 
03521 if(PRINT_TRACING)
03522 { char str[256] ;
03523   sprintf(str," 3D dataset coordinates %d %d %d",
03524           id.ijk[0],id.ijk[1],id.ijk[2] ) ; STATUS(str) ; }
03525 
03526             if( im3d->ignore_seq_callbacks == AFNI_IGNORE_NOTHING ){
03527                AFNI_view_setter(im3d,NULL) ;
03528                AFNI_set_viewpoint(
03529                   im3d ,
03530                   id.ijk[0] , id.ijk[1] , id.ijk[2] ,
03531                   (im3d->vinfo->crosshair_visible==True) ?
03532                   REDISPLAY_OVERLAY : REDISPLAY_OPTIONAL ) ;
03533             }
03534          }
03535       }
03536       break ; /* end of newxyzm */
03537 
03538       /*** User asks for a reference function ***/
03539 
03540       case graCR_pickref:{
03541 
03542 STATUS("graCR_pickref") ;
03543 
03544          if( IMARR_COUNT(GLOBAL_library.timeseries) > 0 ){
03545             int init_ts = AFNI_ts_in_library( im3d->fimdata->fimref ) ;
03546 
03547             MCW_choose_timeseries( grapher->fdw_graph , "FIM Reference Vector" ,
03548                                    GLOBAL_library.timeseries , init_ts ,
03549                                    AFNI_fimmer_pickref_CB , (XtPointer) im3d ) ;
03550          } else {
03551             (void) MCW_popup_message(
03552                       grapher->option_rowcol ,
03553                       "No timeseries library\nexists to pick from!" ,
03554                       MCW_USER_KILL | MCW_TIMER_KILL ) ;
03555          }
03556       }
03557       break ; /* end of pickref */
03558 
03559       /*** User asks for an ort function ***/
03560 
03561       case graCR_pickort:{
03562 
03563 STATUS("graCR_pickort") ;
03564 
03565          if( IMARR_COUNT(GLOBAL_library.timeseries) > 0 ){
03566             int init_ts = AFNI_ts_in_library( im3d->fimdata->fimort ) ;
03567 
03568             MCW_choose_timeseries( grapher->fdw_graph , "FIM Ort Vector" ,
03569                                    GLOBAL_library.timeseries , init_ts ,
03570                                    AFNI_fimmer_pickort_CB , (XtPointer) im3d ) ;
03571          } else {
03572             (void) MCW_popup_message(
03573                       grapher->option_rowcol ,
03574                       "No timeseries library\nexists to pick from!" ,
03575                       MCW_USER_KILL | MCW_TIMER_KILL ) ;
03576          }
03577       }
03578       break ; /* end of pickort */
03579 
03580 
03581       /*** User asks to clear FIM ***/
03582 
03583       case graCR_clearfim:{
03584          AFNI_fimmer_setref( im3d , NULL ) ;
03585          im3d->fimdata->refadd_count = 0 ;
03586       }
03587       break ; /* end of clearfim */
03588 
03589       /*** User asks to clear Ort ***/
03590 
03591       case graCR_clearort:{
03592          AFNI_fimmer_setort( im3d , NULL ) ;
03593       }
03594       break ; /* end of clearfim */
03595 
03596       /*** 27 Jan 2004:
03597            User toggled WinAver on in one graph window,
03598            so we toggle it off in the other windows.    ***/
03599 
03600       case graCR_winaver:{
03601         if( im3d->g123 != NULL && im3d->g123 != grapher )
03602           drive_MCW_grapher( im3d->g123 , graDR_winaver , 0 ) ;
03603         if( im3d->g231 != NULL && im3d->g231 != grapher )
03604           drive_MCW_grapher( im3d->g231 , graDR_winaver , 0 ) ;
03605         if( im3d->g312 != NULL && im3d->g312 != grapher )
03606           drive_MCW_grapher( im3d->g312 , graDR_winaver , 0 ) ;
03607       }
03608       break ; /* end of winaver */
03609 
03610       /*** 12 Nov 1996:
03611            User supplies a timeseries to add to the global library ***/
03612 
03613       case graCR_timeseries_library:{
03614          MRI_IMAGE * tsim = (MRI_IMAGE *) cbs->userdata ;
03615 
03616          AFNI_add_timeseries( tsim ) ;
03617       }
03618       break ; /* end of timeseries_library */
03619 
03620       /*** User supplies a timeseries for FIM (equals or add) ***/
03621 
03622       case graCR_refadd:
03623       case graCR_refequals:{
03624          MRI_IMAGE * tsim = (MRI_IMAGE *) cbs->userdata ;
03625          MRI_IMAGE * qim , * sim ;
03626          float * sar , * qar ;
03627 
03628          if( tsim != NULL ){
03629             qim = mri_to_float( tsim ) ;        /* make a copy of input */
03630             if( im3d->fimdata->fimref == NULL   ||
03631                 cbs->reason == graCR_refequals  ||
03632                 im3d->fimdata->refadd_count < 1   ){
03633 
03634                /** equals **/
03635 
03636                AFNI_fimmer_setref( im3d , qim ) ;
03637                im3d->fimdata->refadd_count = 1 ;
03638 
03639             } else {
03640                int jj,ii , nxs , nyy , nxq , nxx , npix ;
03641                float fs , fq ;
03642 
03643                /** average **/
03644 
03645                sim  = mri_to_float( im3d->fimdata->fimref ) ; /* add into this copy */
03646                sar  = MRI_FLOAT_PTR(sim) ;
03647                qar  = MRI_FLOAT_PTR(qim) ;
03648                nxs  = sim->nx ; nxq = qim->nx ; nxx = MIN(nxs,nxq) ;
03649                nyy  = MIN( sim->ny , qim->ny ) ;
03650                npix = MIN( sim->nvox , qim->nvox ) ;
03651 
03652                fq = 1.0/( im3d->fimdata->refadd_count + 1.0 ) ;
03653                fs = 1.0 - fq ;
03654 
03655                for( jj=0 ; jj < nyy ; jj++ ){
03656                   for( ii=0 ; ii < nxx ; ii++ ){
03657                      if( sar[ii+jj*nxs] >= WAY_BIG || qar[ii+jj*nxq] >= WAY_BIG )
03658                         sar[ii+jj*nxs] = WAY_BIG ;
03659                      else
03660                         sar[ii+jj*nxs] = fs * sar[ii+jj*nxs] + fq * qar[ii+jj*nxq] ;
03661                   }
03662                }
03663                mri_free( qim ) ;
03664 
03665                AFNI_fimmer_setref( im3d , sim ) ;  /* since caller may free it later */
03666                im3d->fimdata->refadd_count++ ;
03667             }
03668          }
03669       }
03670       break ;
03671 
03672       /*** User asks to smooth reference ***/
03673 
03674       case graCR_refsmooth:{
03675          if( im3d->fimdata->fimref != NULL ){
03676             MRI_IMAGE * sim = mri_to_float(im3d->fimdata->fimref) ; /* copy */
03677             float * sar = MRI_FLOAT_PTR(sim) ;
03678             float aa,bb,cc ;
03679             int ii,jj , nx=sim->nx , ny=sim->ny ;
03680 
03681             for( jj=0 ; jj < ny ; jj++ ){
03682                bb = sar[jj*nx] ; cc = sar[1+jj*nx] ;
03683                for( ii=1 ; ii < nx-1 ; ii++ ){
03684                   aa = bb ; bb = cc ; cc = sar[ii+1+jj*nx] ;
03685                   if( aa < WAY_BIG && bb < WAY_BIG &&
03686                       cc < WAY_BIG && ii > im3d->fimdata->init_ignore )
03687                      sar[ii+jj*nx] = OSFILT(aa,bb,cc) ;
03688                }
03689             }
03690             AFNI_fimmer_setref( im3d , sim ) ;
03691          }
03692       }
03693       break ;
03694 
03695       /*** User asks to do fim! ***/
03696 
03697       case graCR_dofim:{
03698          AFNI_fimmer_execute( im3d , cbs->key , cbs->mat ) ;
03699       }
03700       break ; /* end of dofim */
03701 
03702       /*** User sets initial ignore count ***/
03703 
03704       case graCR_setignore:{
03705          AFNI_fimmer_setignore( im3d , cbs->key ) ;
03706       }
03707       break ;
03708 
03709       /*** User sets the polort order [27 May 1999] ***/
03710 
03711       case graCR_polort:{
03712          AFNI_fimmer_setpolort( im3d , cbs->key ) ;
03713       }
03714       break ;
03715 
03716       /*** User sets time_index (from graph) ***/
03717       /*** 24 Jan 2001: or bucket index      ***/
03718       /*** 29 Jul 2003: time_index and anat_index are almost merged now ***/
03719 
03720       case graCR_setindex:{
03721          MCW_arrowval *tav = im3d->vwid->imag->time_index_av ;
03722          MCW_arrowval *aav = im3d->vwid->func->anat_buck_av ;
03723          int new_index = cbs->key ;
03724 
03725          if( new_index != im3d->vinfo->anat_index ){
03726            if( im3d->vinfo->time_on ){
03727              AV_assign_ival( tav , new_index ) ;               /* set time_index */
03728              AFNI_time_index_CB( tav, (XtPointer) im3d ); /* will set anat_index */
03729            } else {
03730              AV_assign_ival( aav, new_index ) ;       /* set anat index directly */
03731              AFNI_bucket_CB( aav, im3d ) ;
03732            }
03733          }
03734       }
03735       break ;
03736 
03737       /*** Feb 1998: user clicked button2 ***/
03738 
03739       case graCR_button2_points:{
03740          THD_ivec3 id ;
03741          int fixed_plane ;
03742 
03743          if( cbs->xcen >= 0 && cbs->xcen < br->n1 &&
03744              cbs->ycen >= 0 && cbs->ycen < br->n2 &&
03745              cbs->zcen >= 0 && cbs->zcen < br->n3   ){
03746 
03747             /* translate image to dataset coordinates */
03748 
03749             id = THD_fdind_to_3dind(
03750                     br , TEMP_IVEC3(cbs->xcen,cbs->ycen,cbs->zcen) );
03751 
03752             /* send a single point */
03753 
03754             fixed_plane = abs(br->a123.ijk[2]) ;
03755 
03756             AFNI_process_drawing( im3d , SINGLE_MODE + fixed_plane ,
03757                                   1, &id.ijk[0], &id.ijk[1], &id.ijk[2] ) ;
03758          }
03759       }
03760       break ;
03761 
03762    } /* end of switch on callback reasons */
03763 
03764   EXRETURN ;
03765 }

01021 { return ; }

07890 {
07891    Three_D_View *im3d = (Three_D_View *) client_data ;
07892    MCW_imseq *seq ;
07893 
07894 ENTRY("AFNI_imag_pop_CB") ;
07895 
07896    if( ! IM3D_VALID(im3d) ) EXRETURN ;
07897 
07898    XtVaGetValues( im3d->vwid->imag->popmenu, XmNuserData, &seq, NULL ) ;
07899    AFNI_view_setter(im3d,seq) ;
07900 
07901    /*-- jump back to old location --*/
07902 
07903    if( w == im3d->vwid->imag->pop_jumpback_pb ){
07904      int ij,jj,kk ;
07905 
07906      ij = im3d->vinfo->i1_old ;  /* extract old place */
07907      jj = im3d->vinfo->j2_old ;
07908      kk = im3d->vinfo->k3_old ;
07909 
07910      SAVE_VPT(im3d) ;  /* save current place as old one */
07911      AFNI_set_viewpoint( im3d , ij,jj,kk , REDISPLAY_OVERLAY ) ; /* jump */
07912    }
07913 
07914    /*-- switch window display mode --*/
07915 
07916    else if( w == im3d->vwid->imag->pop_imageonly_pb ){
07917       if( ISQ_REALZ(seq) )
07918          drive_MCW_imseq( seq , isqDR_onoffwid , (XtPointer) isqDR_togwid ) ;
07919    }
07920 
07921    /*-- jump to a point --*/
07922 
07923    else if( w == im3d->vwid->imag->pop_jumpto_pb &&
07924             im3d->type == AFNI_3DDATA_VIEW         ){
07925 
07926       char tbuf[128] ;
07927 
07928       if( ISQ_REALZ(seq) ){
07929         sprintf(tbuf , "Enter new x y z (%s mm):" , GLOBAL_library.cord.orcode ) ;
07930         MCW_choose_string( seq->wbar , tbuf , NULL ,
07931                            AFNI_jumpto_CB , (XtPointer) im3d ) ;
07932       }
07933    }
07934 
07935    else if( w == im3d->vwid->imag->pop_jumpto_ijk_pb &&
07936             im3d->type == AFNI_3DDATA_VIEW             ){
07937 
07938       if( ISQ_REALZ(seq) ){
07939          MCW_choose_string( seq->wbar , "Enter new i j k:" , NULL ,
07940                             AFNI_jumpto_ijk_CB , (XtPointer) im3d ) ;
07941       }
07942    }
07943 
07944    /*-- 01 May 2002: jump to MNI coordinates --*/
07945 
07946    else if( w == im3d->vwid->imag->pop_mnito_pb &&
07947             im3d->type == AFNI_3DDATA_VIEW        ){
07948 
07949       if( ISQ_REALZ(seq) && CAN_TALTO(im3d) ){
07950          MCW_choose_string( seq->wbar , "Enter MNI x,y,z:" , NULL ,
07951                             AFNI_mnito_CB , (XtPointer) im3d ) ;
07952       } else {
07953          XBell(XtDisplay(w),100) ; /* should never happen */
07954       }
07955    }
07956 
07957    /*-- 06 Mar 2002: jump to a node in a surface --*/
07958 
07959    else if( w == im3d->vwid->imag->pop_sumato_pb &&
07960             SESSION_HAS_SUMA(im3d->ss_now)       &&
07961             im3d->type == AFNI_3DDATA_VIEW         ){
07962 
07963       if( ISQ_REALZ(seq) ){
07964          MCW_choose_string( seq->wbar , "Enter SUMA node ID:" , NULL ,
07965                             AFNI_sumato_CB , (XtPointer) im3d ) ;
07966       }
07967    }
07968 
07969    /*-- jump to a predetermined Talairach anatomical reference point --*/
07970 
07971    else if( w == im3d->vwid->imag->pop_talto_pb &&
07972             im3d->type == AFNI_3DDATA_VIEW      &&
07973             CAN_TALTO(im3d)                       ){
07974 
07975       if( ! TTO_labeled ){  /* initialize labels */
07976          int ii ;
07977          for( ii=0 ; ii < TTO_COUNT ; ii++ ){
07978             TTO_labels[ii] = (char *) malloc( sizeof(char) * TTO_LMAX ) ;
07979             sprintf( TTO_labels[ii] , TTO_FORMAT , TTO_list[ii].name ,
07980                      TTO_list[ii].xx , TTO_list[ii].yy , TTO_list[ii].zz ) ;
07981          }
07982          TTO_labeled = 1 ;
07983       }
07984       if( ISQ_REALZ(seq) ){
07985          MCW_choose_strlist( seq->wbar ,
07986                              "Brain Structure (from San Antonio Talairach Daemon)" ,
07987                              TTO_COUNT , TTO_current , TTO_labels ,
07988                              AFNI_talto_CB , (XtPointer) im3d ) ;
07989       }
07990    }
07991 
07992    /*---- 10 Jul 2001: Talairach "Where Am I?" ----*/
07993 
07994    else if( w == im3d->vwid->imag->pop_whereami_pb &&
07995             w != NULL                              &&
07996             im3d->type == AFNI_3DDATA_VIEW         &&
07997             CAN_TALTO(im3d)                          ){
07998 
07999       char *tlab ;
08000 
08001       /*- if one is already open, kill it -*/
08002 
08003       if( im3d->vwid->imag->pop_whereami_twin != NULL ){
08004          MCW_textwinkill_CB(NULL,
08005                             (XtPointer)im3d->vwid->imag->pop_whereami_twin,NULL);
08006          im3d->vwid->imag->pop_whereami_twin = NULL ;
08007       }
08008 
08009       /*- get TT atlas location, if any -*/
08010 
08011       tlab = AFNI_ttatlas_query( im3d ) ;
08012 
08013       /*- open a window to show it -*/
08014 
08015       if( tlab != NULL ){
08016 
08017          im3d->vwid->imag->pop_whereami_twin =
08018            new_MCW_textwin_2001( seq->wbar , tlab , TEXT_READONLY ,
08019                                  AFNI_pop_whereami_kill , im3d     ) ;
08020 
08021 #if 0
08022          /* 31 Jul 2001: NULL out the pointer when the window is destroyed */
08023 
08024          NULLIFY_ON_DESTROY( im3d->vwid->imag->pop_whereami_twin ,
08025                              im3d->vwid->imag->pop_whereami_twin->wshell ) ;
08026 #endif
08027 
08028          XtVaSetValues( im3d->vwid->imag->pop_whereami_twin->wtext ,
08029                           XmNresizeHeight , True ,
08030                           XmNresizeWidth  , True ,
08031                         NULL ) ;
08032 
08033          MCW_register_hint( im3d->vwid->imag->pop_whereami_twin->wtext ,
08034                             "Use BHelp for documentation" ) ;
08035 
08036          MCW_register_help( im3d->vwid->imag->pop_whereami_twin->wtext ,
08037           "Lists the brain structures near the crosshair focus point\n"
08038           "according to the Talairach Daemon database (kindly provided\n"
08039           "by Jack Lancaster and Peter Fox of RIC UTHSCSA).\n"
08040           "\n"
08041           "The search is conducted outwards from the focus point, until\n"
08042           "9 different structures are found, or a 7 mm radius is reached,\n"
08043           "whichever occurs first. (Distances are rounded to nearest 1 mm,\n"
08044           "the grid spacing on which the database is constructed.) Labels\n"
08045           "reported on different output lines came from different voxels.\n"
08046           "\n"
08047           "In the database, some voxels have 2 labels - a larger scale\n"
08048           "'gyral' name and a finer scale 'area' name.  Locations that\n"
08049           "are doubly labeled will appear with a listing like\n"
08050           "    Within 2 mm: Right Precuneus -AND- Right Brodmann area 31\n"
08051           "In the database there are\n"
08052           "    1,205,737 voxels with at least one label\n"
08053           "      709,953 voxels with only a 'gyral' label\n"
08054           "       15,898 voxels with only a 'area' label\n"
08055           "      479,886 voxels with both types of labels\n"
08056           "A list of all the labels (of either type) is presented by the\n"
08057           "'Talairach to' control.  In the database, there are\n"
08058           "           50 'gyral' labels (times 2 for Left and Right)\n"
08059           "           68 'area' labels\n"
08060           "          355 distinct combinations of labels\n"
08061           "Note Very Well:\n"
08062           "* This feature of AFNI is experimental, and is subject to change.\n"
08063           "* The Atlas is only useful as a ROUGH guide to determining where\n"
08064           "    you are in any individual brain.  Do not rely exclusively on\n"
08065           "    the Atlas for brain region identification: you must use your\n"
08066           "    knowledge, skills, and abilities as well.\n"
08067           "* Do NOT use this feature for surgical or therapeutic planning!!!"
08068          ) ;
08069 
08070          free(tlab) ;
08071       }
08072    }
08073 
08074    /*---- 12 Jul 2001 ----*/
08075 
08076    else if( w == im3d->vwid->imag->pop_ttren_pb           &&
08077             w != NULL                                     &&
08078             im3d->type == AFNI_3DDATA_VIEW                &&
08079             im3d->vinfo->view_type == VIEW_TALAIRACH_TYPE && /* 01 Aug 2001 */
08080             CAN_TALTO(im3d)                                 ){
08081 
08082       TTRR_popup( im3d ) ;
08083    }
08084 
08085    /*---- 05 Nov 2003: start the Edit Environment pseudo-plugin ----*/
08086 
08087    else if( w == im3d->vwid->imag->pop_environment_pb &&
08088             w != NULL                                   ){
08089 
08090      AFNI_misc_CB( im3d->vwid->dmode->misc_environ_pb ,
08091                    (XtPointer) im3d , (XtPointer) NULL ) ;
08092    }
08093 
08094    /*---- 17 May 2005: open Draw Dataset plugin ----*/
08095 
08096    else if( w == im3d->vwid->imag->pop_drawdataset_pb &&
08097             w != NULL                                   ){
08098 
08099      char cmd[128] , cc='A'+AFNI_controller_index(im3d) ;
08100      int xx,yy ;
08101 
08102 #if 0
08103      MCW_widget_geom(im3d->vwid->top_shell,NULL,NULL,&xx,&yy); xx+=29; yy+=19;
08104 #else
08105      xx = im3d->vwid->butx ; yy = im3d->vwid->buty ;
08106 #endif
08107      sprintf(cmd,"OPEN_WINDOW %c.plugin.Draw_Dataset geom=+%d+%d",cc,xx,yy) ;
08108      (void) AFNI_driver(cmd) ;
08109    }
08110 
08111    /*--- unmap of the popup itself [elided] ---*/
08112 
08113    /*--- exit ---*/
08114 
08115    RESET_AFNI_QUIT(im3d) ;
08116    EXRETURN ;
08117 }

09157 {
09158    THD_3dim_dataset * adam_dset ;  /* the farthest ancestor */
09159    THD_warp         * warp_total ; /* the warp from that ancestor */
09160    THD_fvec3          xnew_bot , xnew_top ;
09161 
09162    THD_3dim_dataset * new_dset ;
09163    THD_datablock    * new_dblk  , * adam_dblk  , * parent_dblk ;
09164    THD_dataxes      * new_daxes , * adam_daxes , * parent_daxes ;
09165    THD_diskptr      * new_dkptr , * adam_dkptr , * parent_dkptr ;
09166    THD_marker_set   * new_markers ;
09167 
09168    int new_nx , new_ny , new_nz , ii ;
09169    THD_ivec3 ivbot , ivtop ;
09170 
09171 ENTRY("AFNI_init_warp") ;
09172 
09173    /*----- It is possible that this warp is one in a succession
09174            of warps.  In that case, the actual transformation is
09175            to be done directly from the "adam" dataset, rather
09176            than in succession from the parent.  The reason for
09177            this is to avoid repeated interpolation.  Thus, we
09178            first scan backward along the line of descent, and
09179            create the total warp from "adam" to the new dataset -----*/
09180 
09181    adam_dset   = parent_dset ;
09182    warp_total  = myXtNew( THD_warp ) ;  /* copy initial warp into final warp */
09183    *warp_total = *warp_init ;
09184 
09185    while( adam_dset->warp != NULL ){
09186       AFNI_concatenate_warp( warp_total , adam_dset->warp ) ;
09187       adam_dset = adam_dset->warp_parent ;
09188    }
09189 
09190    if( warp_total->type < FIRST_WARP_TYPE ||
09191        warp_total->type > LAST_WARP_TYPE    ) RETURN(NULL) ;  /* error! */
09192 
09193 #ifdef AFNI_DEBUG
09194 { char str[256] ;
09195   sprintf(str,"parent = %s ; adam = %s",
09196           parent_dset->self_name , adam_dset->self_name ) ;
09197   STATUS(str) ;
09198 
09199   STATUS("warp_total dump:") ;
09200   if( warp_total->type == WARP_AFFINE_TYPE ){
09201      DUMP_LMAP(warp_total->rig_bod.warp) ;
09202   } else {
09203      DUMP_T12_WARP(warp_total->tal_12) ;
09204   }
09205 }
09206 #endif
09207 
09208    adam_dblk  = adam_dset->dblk ;
09209    adam_daxes = adam_dset->daxes ;
09210    adam_dkptr = adam_dblk->diskptr ;
09211 
09212    parent_dblk  = parent_dset->dblk ;
09213    parent_daxes = parent_dset->daxes ;
09214    parent_dkptr = parent_dblk->diskptr ;
09215 
09216    /*----- We now determine the bounding box of the new dataset.
09217            This depends on the warp type:
09218               affine warps   --> use transformed bounding box of adam;
09219               Talairach warp --> use Talairach standard geometry;
09220            The results are in the vectors xnew_bot and xnew_top. -----*/
09221 
09222    switch( warp_total->type ){
09223 
09224       default:  RETURN(NULL) ;  /* something bad happened */
09225 
09226       /*--- 12 case Talairach mapping
09227             (sizes chosen to include borders of Atlas figures) ---*/
09228 
09229       case WARP_TALAIRACH_12_TYPE:{
09230          int   use_tlrc_big=MCW_val_bbox( im3d->vwid->marks->tlrc_big_bbox ) ;
09231          float xtop=ATLAS_BBOX_LAT ,
09232                ybot=ATLAS_BBOX_ANT ,
09233                ytop=ATLAS_BBOX_POS ,
09234                zbot=(use_tlrc_big) ? ATLAS_BBOX_INF_NEW : ATLAS_BBOX_INF ,
09235                ztop=ATLAS_BBOX_SUP ;
09236 
09237 #define GETVAL(vvv,nnn) do{ char *eee = getenv(nnn) ;                            \
09238                             if( eee != NULL ){                                   \
09239                               float val=strtod(eee,NULL); if(val>0.0) vvv = val; \
09240                             } } while(0)
09241 
09242          GETVAL(xtop,"AFNI_TLRC_BBOX_LAT") ;  /* 16 Apr 2002: get new bounding box */
09243          GETVAL(ybot,"AFNI_TLRC_BBOX_ANT") ;  /* from environment variables, maybe */
09244          GETVAL(ytop,"AFNI_TLRC_BBOX_POS") ;
09245          GETVAL(zbot,"AFNI_TLRC_BBOX_INF") ;
09246          GETVAL(ztop,"AFNI_TLRC_BBOX_SUP") ;
09247 
09248 #undef GETVAL
09249 
09250          LOAD_FVEC3( xnew_bot ,-xtop,-ybot,-zbot ) ;
09251          LOAD_FVEC3( xnew_top , xtop, ytop, ztop ) ;
09252       }
09253       break ;
09254 
09255       /*--- linear warp ---*/
09256 
09257       case WARP_AFFINE_TYPE:{
09258          THD_fvec3 corner , base , xnew , aff_bot , aff_top ;
09259          THD_mat33 to_new ;
09260 
09261          to_new  = warp_total->rig_bod.warp.mfor ;
09262          base    = warp_total->rig_bod.warp.bvec ;
09263 
09264          /*--- transform each of the 8 corner locations in
09265                the adam dataset to the aligned system, and
09266                determine the outer limits of the new datablock ---*/
09267 
09268          LOAD_FVEC3(corner,adam_daxes->xxmin,
09269                            adam_daxes->yymin,adam_daxes->zzmin) ;  /* 1 */
09270          corner   = THD_3dmm_to_dicomm( adam_dset , corner ) ;
09271          xnew_bot = xnew_top = MATVEC_SUB(to_new,corner,base) ;
09272 
09273          LOAD_FVEC3(corner,adam_daxes->xxmax,
09274                            adam_daxes->yymin,adam_daxes->zzmin) ;  /* 2 */
09275          corner   = THD_3dmm_to_dicomm( adam_dset , corner ) ;
09276          xnew     = MATVEC_SUB(to_new,corner,base) ;
09277          xnew_bot = MIN_FVEC3(xnew_bot,xnew) ;
09278          xnew_top = MAX_FVEC3(xnew_top ,xnew ) ;
09279 
09280          LOAD_FVEC3(corner,adam_daxes->xxmin,
09281                            adam_daxes->yymax,adam_daxes->zzmin) ;  /* 3 */
09282          corner   = THD_3dmm_to_dicomm( adam_dset , corner ) ;
09283          xnew     = MATVEC_SUB(to_new,corner,base) ;
09284          xnew_bot = MIN_FVEC3(xnew_bot,xnew) ;
09285          xnew_top = MAX_FVEC3(xnew_top ,xnew ) ;
09286 
09287          LOAD_FVEC3(corner,adam_daxes->xxmax,
09288                            adam_daxes->yymax,adam_daxes->zzmin) ;  /* 4 */
09289          corner   = THD_3dmm_to_dicomm( adam_dset , corner ) ;
09290          xnew     = MATVEC_SUB(to_new,corner,base) ;
09291          xnew_bot = MIN_FVEC3(xnew_bot,xnew) ;
09292          xnew_top = MAX_FVEC3(xnew_top ,xnew ) ;
09293 
09294          LOAD_FVEC3(corner,adam_daxes->xxmin,
09295                            adam_daxes->yymin,adam_daxes->zzmax) ;  /* 5 */
09296          corner   = THD_3dmm_to_dicomm( adam_dset , corner ) ;
09297          xnew     = MATVEC_SUB(to_new,corner,base) ;
09298          xnew_bot = MIN_FVEC3(xnew_bot,xnew) ;
09299          xnew_top = MAX_FVEC3(xnew_top ,xnew ) ;
09300 
09301          LOAD_FVEC3(corner,adam_daxes->xxmax,
09302                            adam_daxes->yymin,adam_daxes->zzmax) ;  /* 6 */
09303          corner   = THD_3dmm_to_dicomm( adam_dset , corner ) ;
09304          xnew     = MATVEC_SUB(to_new,corner,base) ;
09305          xnew_bot = MIN_FVEC3(xnew_bot,xnew) ;
09306          xnew_top = MAX_FVEC3(xnew_top ,xnew ) ;
09307 
09308          LOAD_FVEC3(corner,adam_daxes->xxmin,
09309                            adam_daxes->yymax,adam_daxes->zzmax) ;  /* 7 */
09310          corner   = THD_3dmm_to_dicomm( adam_dset , corner ) ;
09311          xnew     = MATVEC_SUB(to_new,corner,base) ;
09312          xnew_bot = MIN_FVEC3(xnew_bot,xnew) ;
09313          xnew_top = MAX_FVEC3(xnew_top ,xnew ) ;
09314 
09315          LOAD_FVEC3(corner,adam_daxes->xxmax,
09316                            adam_daxes->yymax,adam_daxes->zzmax) ;  /* 8 */
09317          corner   = THD_3dmm_to_dicomm( adam_dset , corner ) ;
09318          xnew     = MATVEC_SUB(to_new,corner,base) ;
09319          xnew_bot = MIN_FVEC3(xnew_bot,xnew) ;
09320          xnew_top = MAX_FVEC3(xnew_top ,xnew ) ;
09321 
09322          /* If the warp had any data in it about
09323             the region to map to, apply that data. */
09324 
09325          aff_bot = warp_total->rig_bod.warp.bot  ;
09326          aff_top = warp_total->rig_bod.warp.top  ;
09327 
09328          if( (aff_bot.xyz[0] < aff_top.xyz[0]) &&
09329              (aff_bot.xyz[1] < aff_top.xyz[1]) &&
09330              (aff_bot.xyz[2] < aff_top.xyz[2])   ){
09331 
09332    /* 3/25/95: use the bot & top INSTEAD of the corners
09333                (old version used in ADDITION to corners) */
09334 
09335 #if 0
09336             xnew_bot = MIN_FVEC3(xnew_bot,aff_bot) ;
09337             xnew_top = MAX_FVEC3(xnew_top,aff_top) ;
09338 #else
09339             xnew_bot = aff_bot ;
09340             xnew_top = aff_top ;
09341 #endif
09342          }
09343 
09344       }  /* end of affine warp case */
09345       break ;
09346 
09347    } /* end of xnew_bot & xnew_top computed from warp */
09348 
09349    /* force bounds to be integral multiples of resampling size */
09350 
09351 #define FLOOR(qq) ( ((qq) >= 0) ? ((int)(qq)) : (-1+(int)(qq)) )
09352 
09353    ivbot.ijk[0] = FLOOR( 0.01 + xnew_bot.xyz[0] / resam_vox ) ;
09354    ivbot.ijk[1] = FLOOR( 0.01 + xnew_bot.xyz[1] / resam_vox ) ;
09355    ivbot.ijk[2] = FLOOR( 0.01 + xnew_bot.xyz[2] / resam_vox ) ;
09356 
09357    ivtop.ijk[0] = FLOOR( 0.99 + xnew_top.xyz[0] / resam_vox ) ;
09358    ivtop.ijk[1] = FLOOR( 0.99 + xnew_top.xyz[1] / resam_vox ) ;
09359    ivtop.ijk[2] = FLOOR( 0.99 + xnew_top.xyz[2] / resam_vox ) ;
09360 
09361 #undef FLOOR
09362 
09363    xnew_bot.xyz[0] = ivbot.ijk[0] * resam_vox ;
09364    xnew_bot.xyz[1] = ivbot.ijk[1] * resam_vox ;
09365    xnew_bot.xyz[2] = ivbot.ijk[2] * resam_vox ;
09366 
09367    xnew_top.xyz[0] = ivtop.ijk[0] * resam_vox ;
09368    xnew_top.xyz[1] = ivtop.ijk[1] * resam_vox ;
09369    xnew_top.xyz[2] = ivtop.ijk[2] * resam_vox ;
09370 
09371    /* compute dimensions of the new brick */
09372 
09373    new_nx = (xnew_top.xyz[0] - xnew_bot.xyz[0])/resam_vox + 1.5 ;
09374    new_ny = (xnew_top.xyz[1] - xnew_bot.xyz[1])/resam_vox + 1.5 ;
09375    new_nz = (xnew_top.xyz[2] - xnew_bot.xyz[2])/resam_vox + 1.5 ;
09376 
09377    xnew_top.xyz[0] = xnew_bot.xyz[0] + (new_nx-1) * resam_vox ;
09378    xnew_top.xyz[1] = xnew_bot.xyz[1] + (new_ny-1) * resam_vox ;
09379    xnew_top.xyz[2] = xnew_bot.xyz[2] + (new_nz-1) * resam_vox ;
09380 
09381 #ifdef AFNI_DEBUG
09382 DUMP_FVEC3("  -- xnew_bot",xnew_bot) ;
09383 DUMP_FVEC3("  -- xnew_top",xnew_top) ;
09384 printf("  ==> new nx=%d ny=%d nz=%d\n",new_nx,new_ny,new_nz) ;
09385 #endif
09386 
09387    /*----- make a new 3D dataset !!! -----*/
09388 
09389    new_dset    =                     myXtNew( THD_3dim_dataset ) ;
09390    new_dblk    = new_dset->dblk    = myXtNew( THD_datablock ) ;
09391    new_daxes   = new_dset->daxes   = myXtNew( THD_dataxes ) ;
09392    new_markers = new_dset->markers = NULL ;                 /* later, dude */
09393    new_dkptr   = new_dblk->diskptr = myXtNew( THD_diskptr ) ;
09394 
09395    INIT_KILL(new_dset->kl) ; INIT_KILL(new_dblk->kl) ;
09396 
09397    ADDTO_KILL(new_dset->kl,new_dblk)  ;
09398    ADDTO_KILL(new_dset->kl,new_daxes) ;
09399    ADDTO_KILL(new_dset->kl,new_dkptr) ;
09400 
09401    ADDTO_KILL(new_dset->kl,warp_total) ;
09402 
09403    new_dset->wod_daxes = NULL ;
09404    new_dset->wod_flag  = True ;
09405 
09406    new_dset->taxis = NULL ;
09407    new_dset->tagset = NULL ;  /* Oct 1998 */
09408 
09409    INIT_STAT_AUX( new_dset , MAX_STAT_AUX , parent_dset->stat_aux ) ;
09410 
09411 #define PARENT_MYSELF  /* 14 Dec 1999 */
09412 
09413    new_dset->idcode             = MCW_new_idcode() ;
09414    new_dset->warp_parent_idcode = adam_dset->idcode ;
09415 #ifndef PARENT_MYSELF
09416    ZERO_IDCODE(new_dset->anat_parent_idcode) ;
09417    new_dset->anat_parent = NULL ;
09418 #else
09419    new_dset->anat_parent_idcode = new_dset->idcode ; /* 14 Dec 1999 */
09420    new_dset->anat_parent        = new_dset ;         /* 14 Dec 1999 */
09421 #endif
09422 
09423    EMPTY_STRING(new_dset->anat_parent_name) ;
09424 
09425    /*------------ initialize dataset fields -------------*/
09426    /**** July 1997: be careful about adam and parent ****/
09427 
09428 STATUS("init new_dset") ;
09429 
09430    new_dset->type      = parent_dset->type;                    /* data types */
09431    new_dset->func_type = parent_dset->func_type;
09432    new_dset->view_type = WARPED_VIEW(parent_dset->view_type) ; /* view type */
09433 
09434    new_dset->warp      = warp_total ;                          /* warp info */
09435    new_dset->vox_warp  = NULL ;
09436    new_dset->self_warp = NULL ;    /* 26 Aug 2002 */
09437 
09438    new_dset->warp_parent = adam_dset ;
09439    MCW_strncpy( new_dset->warp_parent_name ,
09440                 adam_dset->self_name       , THD_MAX_NAME ) ;
09441 
09442    MCW_strncpy( new_dset->label1 , parent_dset->label1 , THD_MAX_LABEL ) ;
09443    MCW_strncpy( new_dset->label2 , parent_dset->label2 , THD_MAX_LABEL ) ;
09444 
09445    MCW_strncpy( new_dset->self_name  ,
09446                 parent_dset->self_name , THD_MAX_NAME ) ;  /* make up */
09447    ii = strlen( new_dset->self_name ) ;                    /* a new name */
09448    new_dset->self_name[ii++] = '+' ;
09449    MCW_strncpy( &(new_dset->self_name[ii]) ,
09450                 VIEW_typestr[new_dset->view_type] ,
09451                 THD_MAX_NAME-ii ) ;
09452 
09453    new_dset->death_mark  = 0 ;
09454    new_dset->tcat_list   = 0 ;
09455    new_dset->tcat_num    = 0 ;
09456    new_dset->tcat_len    = NULL ;
09457 
09458    /*--- initialize disk pointer fields ---*/
09459 
09460 STATUS("init new_dkptr") ;
09461 
09462    new_dkptr->type         = DISKPTR_TYPE ;
09463    new_dkptr->rank         = 3 ;
09464    new_dkptr->nvals        = adam_dkptr->nvals ;
09465    new_dkptr->dimsizes[0]  = new_nx ;
09466    new_dkptr->dimsizes[1]  = new_ny ;
09467    new_dkptr->dimsizes[2]  = new_nz ;
09468    new_dkptr->storage_mode = STORAGE_UNDEFINED ;
09469    new_dkptr->byte_order   = THD_get_write_order() ;  /* 25 April 1998 */
09470 
09471    THD_init_diskptr_names( new_dkptr ,
09472                            parent_dkptr->directory_name, NULL, parent_dkptr->prefix ,
09473                            new_dset->view_type , True ) ;
09474 
09475    /*--- initialize datablock fields ---*/
09476 
09477 STATUS("init new_dblk") ;
09478 
09479    new_dblk->type        = DATABLOCK_TYPE ;
09480    new_dblk->nvals       = adam_dblk->nvals ;
09481    new_dblk->malloc_type = DATABLOCK_MEM_UNDEFINED ;
09482    new_dblk->natr        = new_dblk->natr_alloc = 0 ;
09483    new_dblk->atr         = NULL ;
09484    new_dblk->parent      = (XtPointer) new_dset ;
09485 
09486    new_dblk->brick_fac   = NULL ;  /* THD_init_datablock_brick */
09487    new_dblk->brick_bytes = NULL ;  /* will initialize these arrays */
09488    new_dblk->brick       = NULL ;
09489    THD_init_datablock_brick( new_dblk , -1 , adam_dblk ) ;
09490 
09491    new_dblk->master_nvals = 0 ;     /* 11 Jan 1999 */
09492    new_dblk->master_ival  = NULL ;
09493    new_dblk->master_bytes = NULL ;
09494 
09495    DSET_unlock(new_dset) ;
09496 
09497    THD_null_datablock_auxdata( new_dblk ) ;
09498    THD_copy_datablock_auxdata( adam_dblk , new_dblk ) ; /* 30 Nov 1997 */
09499 
09500    /*--- initialize data axes fields ---*/
09501 
09502 STATUS("init new_daxes") ;
09503 
09504    new_daxes->type     = DATAXES_TYPE ;
09505    new_daxes->nxx      = new_nx ;
09506    new_daxes->nyy      = new_ny ;
09507    new_daxes->nzz      = new_nz ;
09508    new_daxes->xxorg    = xnew_bot.xyz[0] ;
09509    new_daxes->yyorg    = xnew_bot.xyz[1] ;
09510    new_daxes->zzorg    = xnew_bot.xyz[2] ;
09511    new_daxes->xxdel    = resam_vox ;       /* cubical voxels */
09512    new_daxes->yydel    = resam_vox ;
09513    new_daxes->zzdel    = resam_vox ;
09514    new_daxes->xxmin    = xnew_bot.xyz[0] ; /* save new bounding box */
09515    new_daxes->yymin    = xnew_bot.xyz[1] ;
09516    new_daxes->zzmin    = xnew_bot.xyz[2] ;
09517    new_daxes->xxmax    = xnew_top.xyz[0] ;
09518    new_daxes->yymax    = xnew_top.xyz[1] ;
09519    new_daxes->zzmax    = xnew_top.xyz[2] ;
09520    new_daxes->parent   = (XtPointer) new_dset ;
09521 
09522    new_daxes->xxorient = ORI_R2L_TYPE ;    /* Dicom standard axes! */
09523    new_daxes->yyorient = ORI_A2P_TYPE ;
09524    new_daxes->zzorient = ORI_I2S_TYPE ;
09525    LOAD_DIAG_MAT(new_daxes->to_dicomm,1,1,1) ;  /* identity matrix */
09526 
09527    /*--- if view type is appropriate, set new markers ---*/
09528 
09529    switch( new_dset->view_type ){
09530 
09531       default:
09532 STATUS("no new_markers") ;
09533       break ;   /* no markers */
09534 
09535       /*--- AC-PC aligned ==> can do the BOUNDING set of markers ---*/
09536 
09537       case VIEW_ACPCALIGNED_TYPE:
09538       if( new_dset->type == HEAD_ANAT_TYPE ){
09539          int ii , jj ;
09540 
09541 STATUS("init new_markers") ;
09542 
09543          new_markers = new_dset->markers = myXtNew( THD_marker_set ) ;
09544          ADDTO_KILL(new_dset->kl,new_markers) ;
09545 
09546          new_markers->numdef = NMARK_BOUNDING ;
09547          new_markers->numset = 0 ;                /* null data out */
09548          for( ii=0 ; ii < MARKS_MAXNUM ; ii++ ){
09549 
09550             new_markers->xyz[ii][0] =
09551               new_markers->xyz[ii][1] =
09552                 new_markers->xyz[ii][2] = -99999999.99 ;
09553 
09554             for( jj=0 ; jj < MARKS_MAXLAB ; jj++ )
09555                new_markers->label[ii][jj] = '\0' ;
09556 
09557             for( jj=0 ; jj < MARKS_MAXHELP ; jj++ )
09558                new_markers->help[ii][jj] = '\0' ;
09559 
09560             new_markers->valid[ii]   = False ;
09561             new_markers->ovcolor[ii] = -1 ;    /* not used yet */
09562          }
09563 
09564          for( ii=0 ; ii < NMARK_BOUNDING ; ii++ ){       /* copy strings in */
09565             MCW_strncpy( &(new_markers->label[ii][0]) ,
09566                          THD_bounding_label[ii] , MARKS_MAXLAB ) ;
09567             MCW_strncpy( &(new_markers->help[ii][0]) ,
09568                          THD_bounding_help[ii] , MARKS_MAXHELP ) ;
09569          }
09570 
09571          for( ii=0 ; ii < MARKS_MAXFLAG ; ii++ )     /* copy flags in */
09572             new_markers->aflags[ii] = THD_bounding_aflags[ii] ;
09573          new_markers->type = new_markers->aflags[0] ;
09574       }
09575       break ;  /* end of BOUNDING markers */
09576 
09577    }  /* end of marker creation */
09578 
09579    /*----- copy statistics, if any -----*/
09580 
09581    new_dset->stats = NULL ;
09582    AFNI_copy_statistics( adam_dset , new_dset ) ;
09583 
09584 #ifdef ALLOW_DATASET_VLIST
09585    new_dset->pts = NULL ;
09586 #endif
09587 
09588    /*----- dataset ready for warping -----*/
09589 
09590    PARENTIZE(new_dset,adam_dset->parent) ;
09591 
09592 STATUS("initialization complete") ;
09593 
09594    RETURN( new_dset ) ;
09595 }

06547 {
06548    int vvv , itog , lll , sss , aaa , fff , id ;
06549    THD_3dim_dataset     * dset , * new_anat , * new_func ;
06550    THD_marker_set       * markers ;
06551    AFNI_viewing_widgets * view ;
06552    AFNI_marks_widgets   * marks ;
06553    THD_fvec3 fv ;
06554    THD_ivec3 iv ;
06555 
06556 ENTRY("AFNI_initialize_view") ;
06557 
06558    if( ! IM3D_VALID(im3d) ) EXRETURN ;
06559 
06560    vvv = im3d->vinfo->view_type ;  /* locations of new data to view */
06561    sss = im3d->vinfo->sess_num ;
06562    aaa = im3d->vinfo->anat_num ;
06563    fff = im3d->vinfo->func_num ;
06564 
06565 if(PRINT_TRACING)
06566 { char str[256] ;
06567   sprintf(str,"view=%d session=%d anat=%d func=%d",vvv,sss,aaa,fff);
06568   STATUS(str) ; }
06569 
06570    new_anat = GLOBAL_library.sslist->ssar[sss]->dsset[aaa][vvv] ;
06571    new_func = GLOBAL_library.sslist->ssar[sss]->dsset[fff][vvv] ;
06572 
06573    /*----------------------------------------------*/
06574    /*--- if the old dataset has markers and the
06575          marker panel is open, shut it down now ---*/
06576 
06577    if( old_anat != NULL     && /** old_anat->markers != NULL && **/
06578        old_anat != new_anat && XtIsManaged(im3d->vwid->marks->frame) ){
06579 
06580       AFNI_marks_action_CB( NULL, (XtPointer) im3d, NULL) ; /* "done" */
06581    }
06582 
06583    if( GLOBAL_argopt.auto_purge == True ){ /* purge old datasets? */
06584 
06585 STATUS("purging old datasets from memory (maybe)") ;
06586 
06587       im3d->anat_now = new_anat ;
06588       im3d->fim_now  = new_func ;
06589       AFNI_purge_unused_dsets() ;
06590    }
06591 
06592    /*---------------------------------------------------------*/
06593    /* set the new datasets that we will deal with from now on */
06594 
06595    for( id=0 ; id <= LAST_VIEW_TYPE ; id++ ){
06596       im3d->anat_dset[id] = GLOBAL_library.sslist->ssar[sss]->dsset[aaa][id] ;
06597       im3d->fim_dset[id]  = GLOBAL_library.sslist->ssar[sss]->dsset[fff][id] ;
06598 
06599       if( ISVALID_3DIM_DATASET(im3d->anat_dset[id]) )
06600          SENSITIZE( im3d->vwid->view->view_bbox->wbut[id], True ) ;
06601       else
06602          SENSITIZE( im3d->vwid->view->view_bbox->wbut[id], False) ;
06603    }
06604 
06605    im3d->anat_now = im3d->anat_dset[vvv] ;
06606    im3d->fim_now  = im3d->fim_dset[vvv] ;
06607    im3d->ss_now   = GLOBAL_library.sslist->ssar[sss] ;
06608 
06609    /*------------------------------------------------*/
06610    /*--- if markers are defined, then set them up ---*/
06611 
06612    dset    = im3d->anat_now ;
06613    markers = dset->markers ;
06614    view    = im3d->vwid->view ;
06615    marks   = im3d->vwid->marks ;
06616 
06617    if( markers == NULL ){   /*--------- markers NOT defined ---------*/
06618 
06619 STATUS("turning markers off") ;
06620 
06621       /* turn controls off */
06622 
06623 #if 0
06624       SENSITIZE(  view->define_marks_pb , False ) ;
06625       SENSITIZE(  view->see_marks_bbox->wrowcol , False ) ;
06626 #endif
06627 
06628       marks->editable = False ;
06629 
06630       vvv = MCW_val_bbox( view->see_marks_bbox ) ;
06631       marks->tag_visible = marks->ov_visible = (vvv) ? True : False ;
06632 
06633       XtUnmanageChildren( marks->always_popup    , marks->num_always_popup    ) ;
06634       XtUnmanageChildren( marks->sometimes_popup , marks->num_sometimes_popup ) ;
06635 
06636    } else {   /*------------- markers ARE defined ----------------*/
06637 
06638 STATUS("turning markers on") ;
06639 
06640       /* turn controls on */
06641 
06642       SENSITIZE( view->define_marks_pb , True ) ;
06643       SENSITIZE( view->see_marks_bbox->wrowcol , True ) ;
06644 
06645       vvv = MCW_val_bbox( view->see_marks_bbox ) ;
06646       marks->tag_visible = marks->ov_visible = (vvv) ? True : False ;
06647 
06648       marks->editable = False ;
06649       MCW_set_bbox( marks->edits_bbox , 0 ) ;
06650 
06651       SENSITIZE( marks->pop_set_pb   , marks->editable ) ;
06652       SENSITIZE( marks->pop_clear_pb , marks->editable ) ;
06653 
06654       /* copy help into location where MCW_help will find it */
06655 
06656       for( itog=0 ; itog < MARKS_MAXNUM ; itog++ ){
06657          MCW_strncpy( &(marks->tog_help[itog][0]) ,
06658                       &(markers->help[itog][0]) , MARKS_MAXHELP ) ;
06659       }
06660 
06661       /* copy the non-empty labels into the toggle labels,
06662          and make the toggle buttons active (panel AND popup) */
06663 
06664       XtManageChildren( marks->always_popup ,
06665                         marks->num_always_popup ) ;
06666 
06667       for( itog=0 ; itog < MARKS_MAXNUM ; itog++ ){
06668          lll = strlen( &(markers->label[itog][0]) ) ;
06669 
06670          if( lll == 0 ){
06671             XtUnmanageChild( marks->tog[itog] ) ;   /* empty label! */
06672             XtUnmanageChild( marks->poptog[itog] ) ;
06673          } else {
06674             MCW_set_widget_label( marks->tog[itog] ,
06675                                   &(markers->label[itog][0]) ) ;
06676             SENSITIZE( marks->tog[itog] , True ) ;
06677             XtManageChild( marks->tog[itog] ) ;
06678 
06679             MCW_set_widget_label( marks->poptog[itog] ,
06680                                   &(markers->label[itog][0]) ) ;
06681             SENSITIZE( marks->poptog[itog] , True ) ;
06682             XtManageChild( marks->poptog[itog] ) ;
06683 
06684             if( markers->valid[itog] && ! marks->inverted[itog] ){
06685                MCW_invert_widget( marks->tog[itog] ) ;
06686                MCW_invert_widget( marks->poptog[itog] ) ;
06687                marks->inverted[itog] = True ;
06688             }
06689 
06690             if( ! markers->valid[itog] && marks->inverted[itog] ){
06691                MCW_invert_widget( marks->tog[itog] ) ;
06692                MCW_invert_widget( marks->poptog[itog] ) ;
06693                marks->inverted[itog] = False ;
06694             }
06695          }
06696       } /* end of loop over markers */
06697 
06698    } /* end of dealing with markers */
06699 
06700    /*------------------------------*/
06701    /*----- set up for viewing -----*/
06702 
06703    AFNI_setup_viewing( im3d , True ) ;
06704 
06705    /*-----------------------------------------------------*/
06706    /*----- reset viewpoint to same Dicom coordinates -----*/
06707 
06708    if( im3d->type == AFNI_3DDATA_VIEW ){
06709       fv = AFNI_transform_vector(
06710               old_anat ,
06711               TEMP_FVEC3( im3d->vinfo->xi, im3d->vinfo->yj, im3d->vinfo->zk ),
06712               dset ) ;
06713 
06714       LOAD_ANAT_VIEW(im3d) ;  /* 02 Nov 1996 */
06715 
06716       fv = THD_dicomm_to_3dmm( dset , fv ) ;
06717       iv = THD_3dmm_to_3dind( dset , fv ) ;
06718    } else {
06719       LOAD_IVEC3( iv, im3d->vinfo->i1, im3d->vinfo->j2, im3d->vinfo->k3 ) ;
06720    }
06721 
06722    /* 27 Jan 2004: set coordinate to center of dataset
06723                    if we were formerly looking at the dummy dataset */
06724 
06725    if( im3d->dummied && !GLOBAL_library.have_dummy_dataset ){
06726      im3d->dummied = 0 ;
06727      LOAD_IVEC3( iv , im3d->anat_now->daxes->nxx/2 ,
06728                       im3d->anat_now->daxes->nyy/2 ,
06729                       im3d->anat_now->daxes->nzz/2  ) ;
06730    }
06731 
06732    DISABLE_LOCK ;  /* 11 Nov 1996 */
06733 
06734    AFNI_view_setter(im3d,NULL) ;
06735    AFNI_set_viewpoint( im3d, iv.ijk[0],iv.ijk[1],iv.ijk[2] , REDISPLAY_ALL ) ;
06736 
06737    ENABLE_LOCK ;   /* 11 Nov 1996 */
06738 
06739    SAVE_VPT(im3d) ;  /* save current location as jumpback */
06740 
06741    EXRETURN ;
06742 }

08299 {
08300    Three_D_View * im3d = (Three_D_View *) cd ;
08301    float xx,yy,zz ;
08302    char dum1[32],dum2[32];
08303    int nn ;
08304 
08305 ENTRY("AFNI_jumpto_CB") ;
08306 
08307    if( ! IM3D_VALID(im3d) || im3d->type != AFNI_3DDATA_VIEW ) EXRETURN ;
08308    if( cbs->reason != mcwCR_string ) EXRETURN ;  /* error */
08309 
08310    nn = sscanf( cbs->cval , "%f%[ ,]%f%[ ,]%f" , &xx,dum1,&yy,dum2,&zz ) ;
08311    if( nn != 5 ){ XBell( im3d->dc->display , 100 ) ; EXRETURN ; }
08312 
08313    THD_coorder_to_dicom( &GLOBAL_library.cord , &xx,&yy,&zz ) ;
08314 
08315    nn = AFNI_jumpto_dicom( im3d , xx,yy,zz ) ;
08316    if( nn < 0 ) XBell( im3d->dc->display , 100 ) ;
08317 
08318    RESET_AFNI_QUIT(im3d) ;
08319    EXRETURN ;
08320 }

08325 {
08326    THD_dataxes  * daxes ;
08327    THD_fvec3 fv ; THD_ivec3 iv ;
08328    int ii,jj,kk ;
08329 
08330 ENTRY("AFNI_jumpto_dicom") ;
08331 
08332    LOAD_ANAT_VIEW(im3d) ;  /* 02 Nov 1996 */
08333 
08334    fv = THD_dicomm_to_3dmm( im3d->anat_now , TEMP_FVEC3(xx,yy,zz) ) ;
08335    iv = THD_3dmm_to_3dind ( im3d->anat_now , fv ) ;
08336    ii = iv.ijk[0] ; jj = iv.ijk[1] ; kk = iv.ijk[2] ;
08337 
08338    daxes = CURRENT_DAXES(im3d->anat_now) ;
08339    if( ii >= 0 && ii < daxes->nxx &&
08340        jj >= 0 && jj < daxes->nyy && kk >= 0 && kk < daxes->nzz ){
08341 
08342       SAVE_VPT(im3d) ;
08343       AFNI_set_viewpoint( im3d , ii,jj,kk , REDISPLAY_ALL ) ; /* jump */
08344       RETURN(1) ;
08345    } else {
08346       XBell( im3d->dc->display , 100 ) ;
08347       RETURN(-1) ;
08348    }
08349 }

08354 {
08355    THD_dataxes * daxes ;
08356 
08357 ENTRY("AFNI_jumpto_ijk") ;
08358 
08359    LOAD_ANAT_VIEW(im3d) ;
08360 
08361    daxes = CURRENT_DAXES(im3d->anat_now) ;
08362    if( ii >= 0 && ii < daxes->nxx &&
08363        jj >= 0 && jj < daxes->nyy && kk >= 0 && kk < daxes->nzz ){
08364 
08365       SAVE_VPT(im3d) ;
08366       AFNI_set_viewpoint( im3d , ii,jj,kk , REDISPLAY_ALL ) ; /* jump */
08367       RETURN(1) ;
08368    } else {
08369       XBell( im3d->dc->display , 100 ) ;
08370       RETURN(-1) ;
08371    }
08372 }

08377 {
08378    Three_D_View * im3d = (Three_D_View *) cd ;
08379    int ii,jj,kk ;
08380    int nn ;
08381    char dum1[32],dum2[32];
08382 
08383 ENTRY("AFNI_jumpto_CB") ;
08384 
08385    if( ! IM3D_VALID(im3d) || im3d->type != AFNI_3DDATA_VIEW ) EXRETURN ;
08386    if( cbs->reason != mcwCR_string ) EXRETURN ;  /* error */
08387 
08388    nn = sscanf( cbs->cval , "%d%[ ,]%d%[ ,]%d" , &ii,dum1,&jj,dum2,&kk ) ;
08389    if( nn != 5 ){ XBell( im3d->dc->display , 100 ) ; EXRETURN ; }
08390 
08391    nn = AFNI_jumpto_ijk( im3d , ii,jj,kk ) ;
08392    if( nn < 0 ) XBell( im3d->dc->display , 100 ) ;
08393 
08394    RESET_AFNI_QUIT(im3d) ;
08395    EXRETURN ;
08396 }

09766 {
09767    char    * xdef ;
09768    Display * display ;
09769    int       ival , ii,jj ;
09770    float     fval ;
09771    char *    cpt ;
09772    char      buf[64] ;
09773    float     pthr[NPANE_MAX+1] ;
09774    int       pov[NPANE_MAX+1] ;
09775 
09776 ENTRY("AFNI_load_defaults") ;
09777 
09778    if( w == NULL ){
09779       fprintf(stderr,"\n*** AFNI_load_defaults: NULL input widget ***\n") ;
09780       EXRETURN ;
09781    }
09782 
09783    display = XtDisplay( w ) ;
09784 
09785    /** initialize overlay color arrays from defaults **/
09786 
09787    for( ii=0 ; ii < DEFAULT_NCOLOVR ; ii++ ){
09788       INIT_colovr[ii] = XtNewString(INIT_def_colovr[ii]) ;
09789       INIT_labovr[ii] = XtNewString(INIT_def_labovr[ii]) ;
09790    }
09791    for( ; ii < MAX_NCOLOVR ; ii++ ){
09792       INIT_colovr[ii] = INIT_labovr[ii] = NULL ;
09793    }
09794 
09795    /** initialize display and overlay colors **/
09796 
09797    NAME2INT("ncolors",INIT_ngray,3,MAX_COLORS) ;
09798 
09799    NAME2INT("ncolovr",INIT_ncolovr,2,MAX_NCOLOVR) ;
09800 
09801    NAME2FLOAT("gamma",INIT_gamma,0.1,9.9) ;
09802 
09803    for( ii=0 ; ii < INIT_ncolovr ; ii++ ){
09804       sprintf( buf , "ovdef%02d" , ii+1 ) ;
09805       NAME2STRING(buf,INIT_colovr[ii] ) ;
09806 
09807       sprintf( buf , "ovlab%02d" , ii+1 ) ;
09808       NAME2STRING(buf,INIT_labovr[ii] ) ;
09809    }
09810 
09811    NAME2INT("ovcrosshair"      , INIT_crosshair_color,0,INIT_ncolovr) ;
09812    NAME2INT("ovmarksprimary"   , INIT_marks1_color   ,0,INIT_ncolovr) ;
09813    NAME2INT("ovmarkssecondary" , INIT_marks2_color   ,0,INIT_ncolovr) ;
09814    NAME2INT("markssize"        , INIT_marks_size     ,2,MAXOVSIZE   ) ;
09815    NAME2INT("marksgap"         , INIT_marks_gap      ,0,MAXOVSIZE-1 ) ;
09816    NAME2INT("crosshairgap"     , INIT_crosshair_gap  ,0,MAXOVSIZE   ) ;
09817    NAME2INT("bigscroll"        , INIT_bigscroll      ,1,MAXOVSIZE   ) ;
09818 
09819    NAME2INT("graph_boxes_color" ,INIT_GR_boxes_color ,BLUEST_COLOR,INIT_ncolovr) ;
09820    NAME2INT("graph_backg_color" ,INIT_GR_backg_color ,BLUEST_COLOR,INIT_ncolovr) ;
09821    NAME2INT("graph_grid_color"  ,INIT_GR_grid_color  ,BLUEST_COLOR,INIT_ncolovr) ;
09822    NAME2INT("graph_text_color"  ,INIT_GR_text_color  ,BLUEST_COLOR,INIT_ncolovr) ;
09823    NAME2INT("graph_data_color"  ,INIT_GR_data_color  ,BLUEST_COLOR,INIT_ncolovr) ;
09824    NAME2INT("graph_ideal_color" ,INIT_GR_ideal_color ,BLUEST_COLOR,INIT_ncolovr) ;
09825    NAME2INT("graph_ort_color"   ,INIT_GR_ort_color   ,BLUEST_COLOR,INIT_ncolovr) ;
09826    NAME2INT("graph_ignore_color",INIT_GR_ignore_color,BLUEST_COLOR,INIT_ncolovr) ;
09827    NAME2INT("graph_dplot_color" ,INIT_GR_dplot_color ,BLUEST_COLOR,INIT_ncolovr) ;
09828 
09829    NAME2INT("graph_boxes_thick" ,INIT_GR_boxes_thick ,0,1) ;
09830    NAME2INT("graph_grid_thick"  ,INIT_GR_grid_thick  ,0,1) ;
09831    NAME2INT("graph_data_thick"  ,INIT_GR_data_thick  ,0,1) ;
09832    NAME2INT("graph_ideal_thick" ,INIT_GR_ideal_thick ,0,1) ;
09833    NAME2INT("graph_ort_thick"   ,INIT_GR_ort_thick   ,0,1) ;
09834    NAME2INT("graph_dplot_thick" ,INIT_GR_dplot_thick ,0,1) ;
09835 
09836    NAME2INT("graph_ggap"        ,INIT_GR_ggap        ,0,19);         /* 27 May 1999 */
09837    NAME2INT("fim_polort"        ,INIT_fim_polort     ,0,MAX_POLORT); /* 30 May 1999 */
09838    NAME2INT("graph_matrix"      ,INIT_GR_gmat        ,1,MAT_MAX);    /* 10 Feb 2003 */
09839    NAME2INT("graph_gthick"      ,INIT_GR_gthick      ,2,10);         /* 06 Oct 2004 */
09840 
09841    /** initialize other junk **/
09842 
09843    cpt = NULL ;
09844    NAME2STRING( "tlrc_big" , cpt ) ;
09845    if( cpt != NULL ){
09846       INIT_tlrc_big = (strcmp(cpt,"True")==0) ? 1 : 0 ;
09847       XtFree(cpt) ;
09848    }
09849 
09850    cpt = NULL ;
09851    NAME2STRING( "montage_periodic" , cpt ) ;
09852    if( cpt != NULL ){
09853       INIT_montage_periodic = (strcmp(cpt,"True")==0) ? 1 : 0 ;
09854       XtFree(cpt) ;
09855    }
09856 
09857    NAME2INT("fim_ignore",INIT_ignore,0,999) ;
09858 
09859    cpt = NULL ;
09860    NAME2STRING( "purge" , cpt ) ;
09861    if( cpt != NULL ){
09862       INIT_purge = (strcmp(cpt,"True")==0) ? 1 : 0 ;
09863       myXtFree(cpt) ;
09864    }
09865 
09866    NAME2FLOAT("resam_vox",INIT_resam_vox,0.1,4.0) ;
09867    INIT_resam_vox = 0.1 * ( (int)(10*INIT_resam_vox) ) ;
09868 
09869    cpt = NULL ;
09870    NAME2STRING( "resam_anat" , cpt ) ;
09871    if( cpt != NULL ){
09872       for( ii=FIRST_RESAM_TYPE ; ii <= LAST_RESAM_TYPE ; ii++ ){
09873          if( strcmp(cpt,RESAM_shortstr[ii]) == 0 ) break ;
09874       }
09875       if( ii <= LAST_RESAM_TYPE ) INIT_resam_anat = ii ;
09876       myXtFree(cpt) ;
09877    }
09878 
09879    cpt = NULL ;
09880    NAME2STRING( "resam_func" , cpt ) ;
09881    if( cpt != NULL ){
09882       for( ii=FIRST_RESAM_TYPE ; ii <= LAST_RESAM_TYPE ; ii++ ){
09883          if( strcmp(cpt,RESAM_shortstr[ii]) == 0 ) break ;
09884       }
09885       if( ii <= LAST_RESAM_TYPE ) INIT_resam_func = ii ;
09886       (char*)myXtFree(cpt) ;
09887    }
09888 
09889    cpt = NULL ;
09890    NAME2STRING( "resam_thr" , cpt ) ;
09891    if( cpt != NULL ){
09892       for( ii=FIRST_RESAM_TYPE ; ii <= LAST_RESAM_TYPE ; ii++ ){
09893          if( strcmp(cpt,RESAM_shortstr[ii]) == 0 ) break ;
09894       }
09895       if( ii <= LAST_RESAM_TYPE ) INIT_resam_thr = ii ;
09896       myXtFree(cpt) ;
09897    }
09898 
09899    /** initialize pbar panes **/
09900 
09901    cpt = NULL ;
09902    NAME2STRING( "pbar_posfunc" , cpt ) ;
09903    if( cpt != NULL ){
09904       INIT_posfunc = (strcmp(cpt,"True")==0) ? 1 : 0 ;
09905       myXtFree(cpt) ;
09906    }
09907 
09908    cpt = NULL ;
09909    NAME2STRING( "pbar_hide" , cpt ) ;
09910    if( cpt != NULL ){
09911       INIT_panes_hide = (strcmp(cpt,"True")==0) ? 1 : 0 ;
09912       myXtFree(cpt) ;
09913    }
09914 
09915    NAME2INT("pbar_pos_pane_count" , INIT_panes_pos , NPANE_MIN , NPANE_MAX ) ;
09916    NAME2INT("pbar_sgn_pane_count" , INIT_panes_sgn , NPANE_MIN , NPANE_MAX ) ;
09917 
09918    /* start with positive panes */
09919 
09920    for( ii=NPANE_INIT+1 ; ii <= NPANE_MAX ; ii++ ){
09921       fval     = 1.0 / ii ;
09922       pthr[0]  = 1.0 ;
09923       pthr[ii] = 0.0 ;
09924       for( jj=1 ; jj < ii ; jj++ ) pthr[jj] = fval * (ii-jj) ;
09925       for( jj=0 ; jj < ii ; jj++ ) pov[jj]  = (jj % INIT_ncolovr) + 1 ;
09926 
09927       for( jj=0 ; jj <= ii ; jj++ ) INIT_pval_pos[ii][jj] = pthr[jj] ;
09928       for( jj=0 ; jj <  ii ; jj++ ) INIT_ovin_pos[ii][jj] = pov[jj] ;
09929    }
09930 
09931    for( ii=NPANE_MIN ; ii <= NPANE_MAX ; ii++ ){
09932 
09933       for( jj=0 ; jj <= ii ; jj++ ){
09934          sprintf( buf , "pbar_pos_pane%02d_thr%02d" , ii,jj ) ;
09935          pthr[jj] = BAD ;
09936          NAME2FLOAT(buf,pthr[jj],0.0,1.0) ;
09937       }
09938 
09939       for( jj=0 ; jj < ii ; jj++ ){
09940          sprintf( buf , "pbar_pos_pane%02d_ov%02d" , ii,jj ) ;
09941          pov[jj] = BAD ;
09942          NAME2INT(buf,pov[jj],0,INIT_ncolovr) ;
09943       }
09944 
09945       /* check pthr for OK-ness; if not good, skip to next pane count (ii) */
09946 
09947       if( pthr[0] != 1.0 || pthr[jj] != 0.0 ) continue ;
09948       for( jj=1 ; jj <= ii ; jj++ ){
09949          if( pthr[jj] == BAD || pthr[jj] >= pthr[jj-1] ) break ;
09950       }
09951       if( jj <= ii ) continue ;
09952 
09953       /* check pov for OK-ness */
09954 
09955       for( jj=0 ; jj < ii ; jj++ ) if( pov[jj] == BAD ) break ;
09956       if( jj < ii ) continue ;
09957 
09958       /* get to here --> load pthr and pov into arrays */
09959 
09960       for( jj=0 ; jj <= ii ; jj++ ) INIT_pval_pos[ii][jj] = pthr[jj] ;
09961       for( jj=0 ; jj <  ii ; jj++ ) INIT_ovin_pos[ii][jj] = pov[jj] ;
09962 
09963    }
09964 
09965    /** initialize signed pbar panes **/
09966 
09967    for( ii=NPANE_INIT+1 ; ii <= NPANE_MAX ; ii++ ){
09968       fval     =  1.0 / ii ;
09969       pthr[0]  =  1.0 ;
09970       pthr[ii] = -1.0 ;
09971       for( jj=1 ; jj < ii ; jj++ ) pthr[jj] = fval * (ii-2*jj) ;
09972       for( jj=0 ; jj < ii ; jj++ ) pov[jj]  = (jj % INIT_ncolovr) + 1 ;
09973 
09974       for( jj=0 ; jj <= ii ; jj++ ) INIT_pval_sgn[ii][jj] = pthr[jj] ;
09975       for( jj=0 ; jj <  ii ; jj++ ) INIT_ovin_sgn[ii][jj] = pov[jj] ;
09976    }
09977 
09978    for( ii=NPANE_MIN ; ii <= NPANE_MAX ; ii++ ){
09979 
09980       for( jj=0 ; jj <= ii ; jj++ ){
09981          sprintf( buf , "pbar_sgn_pane%02d_thr%02d" , ii,jj ) ;
09982          pthr[jj] = BAD ;
09983          NAME2FLOAT(buf,pthr[jj],-1.0,1.0) ; /* 14 Apr 1999: 0.0 changed to -1.0! */
09984       }
09985 
09986       for( jj=0 ; jj < ii ; jj++ ){
09987          sprintf( buf , "pbar_sgn_pane%02d_ov%02d" , ii,jj ) ;
09988          pov[jj] = BAD ;
09989          NAME2INT(buf,pov[jj],0,INIT_ncolovr) ;
09990       }
09991 
09992       /* check pthr for OK-ness; if not good, skip to next pane count (ii) */
09993 
09994       if( pthr[0] != 1.0 || pthr[jj] != -1.0 ) continue ;
09995       for( jj=1 ; jj <= ii ; jj++ ){
09996          if( pthr[jj] == BAD || pthr[jj] >= pthr[jj-1] ) break ;
09997       }
09998       if( jj <= ii ) continue ;
09999 
10000       /* check pov for OK-ness */
10001 
10002       for( jj=0 ; jj < ii ; jj++ ) if( pov[jj] == BAD ) break ;
10003       if( jj < ii ) continue ;
10004 
10005       /* get to here --> load pthr and pov into arrays */
10006 
10007       for( jj=0 ; jj <= ii ; jj++ ) INIT_pval_sgn[ii][jj] = pthr[jj] ;
10008       for( jj=0 ; jj <  ii ; jj++ ) INIT_ovin_sgn[ii][jj] = pov[jj] ;
10009 
10010    }
10011 
10012    /* 10 Jun 2002: put RGB cyclic maps in place */
10013 
10014 #if defined(RGBCYC_COUNT) && RGBCYC_COUNT <= NPANE_MAX
10015    ii = RGBCYC_COUNT ;
10016    for( jj=0 ; jj < ii ; jj++ ) INIT_ovin_pos[ii][jj] = RGBCYC_FIRST+jj+1 ;
10017    for( jj=0 ; jj < ii ; jj++ ) INIT_ovin_sgn[ii][jj] = RGBCYC_FIRST+jj+1 ;
10018 #endif
10019 
10020    EXRETURN ;
10021 }