do{ int nn , iq ;                                                                \
         if( (name)->num == (name)->nall ){                                            \
            nn = (name)->nall = 1.1*(name)->nall + INC_RSA ;                            \
            (name)->rsarr = realloc( (name)->rsarr,sizeof(RENDER_state *)*nn );          \
            for( iq=(name)->num ; iq < (name)->nall ; iq++ ) (name)->rsarr[iq] = NULL ; } \
         nn = (name)->num ; ((name)->num)++ ;                                             \
         (name)->rsarr[nn] = (imm) ; break ; } while(0)

if( strcmp(left,#nnn) == 0 ){         \
                           rs -> nnn = strtod(right,NULL) ;  \
                           continue ;                        \
                       }

if( strncmp(left,#nnn,strlen(#nnn)) == 0 ){                           \
      char * srb = strstr(left,"[") ;                                    \
      if( srb != NULL ){                                                 \
         int iii = strtol(srb+1,NULL,10) ;                               \
         if( iii >= 0 && iii < mmm ) rs->nnn[iii] = strtod(right,NULL) ; \
      }                                                                  \
      continue ;                                                         \
   }

if( strcmp(left,#nnn) == 0 ){           \
                        rs -> nnn = strtol(right,NULL,10) ;  \
                        continue ;                           \
                     }

do{ if( xhair_flag && dset!=NULL &&                                   \
          ! EQUIV_DATAXES(dset->daxes,im3d->wod_daxes) ){               \
        MCW_set_bbox( xhair_bbox , 0 ) ; xhair_flag = 0 ;               \
        (void) MCW_popup_message( xhair_bbox->wrowcol ,                 \
                                     " Can't overlay AFNI crosshairs\n" \
                                     "because dataset grid and AFNI\n"  \
                                     "viewing grid don't coincide."   , \
                                  MCW_USER_KILL | MCW_TIMER_KILL ) ;    \
        XBell(dc->display,100) ; EXRETURN ;                             \
     } } while(0)

( im3d->vinfo->i1             != xhair_ixold || \
                             im3d->vinfo->j2             != xhair_jyold || \
                             im3d->vinfo->k3             != xhair_kzold || \
                             im3d->vinfo->xhairs_orimask != xhair_omold   )

( ( wfunc_color_pbar->bigcolor[index].r == 0 ) && \
    ( wfunc_color_pbar->bigcolor[index].g == 0 ) && \
    ( wfunc_color_pbar->bigcolor[index].b == 0 ) )

do{ int nn ;                                                         \
         if( (name) != NULL ){                                             \
            for( nn=0 ; nn < (name)->num ; nn++ ) free((name)->rsarr[nn]) ; \
            free((name)->rsarr); free((name)); (name) = NULL; } break; } while(0)

( (f).xyz[0] = (f).xyz[0] / (a) , \
     (f).xyz[1] = (f).xyz[1] / (a) , \
     (f).xyz[2] = (f).xyz[2] / (a) )

((func_dset != NULL && func_see_overlay) ||          \
                      func_see_ttatlas || (xhair_flag && xhair_ovc > 0) )

do{ for( ; fptr[0] != '\n' && fptr[0] != '\0' ; fptr++ ) ;    \
      if( fptr[0] == '\0' ) goto Finished ;                              \
      fptr++ ; } while(0)

do{ int sel_height ;  XtPointer sel_ptr ;                  \
         if( wfunc_thr_scale != NULL ){                         \
           XtVaGetValues( wfunc_thr_scale ,                     \
                             XmNuserData , &sel_ptr , NULL ) ;  \
           sel_height = (int) sel_ptr ;                         \
           XtVaSetValues( wfunc_thr_scale ,                     \
                             XmNheight , sel_height , NULL ) ;  \
           XtManageChild(wfunc_thr_scale) ;                     \
       } } while(0)

do{ if( (name) != NULL ){ \
            free((name)->rsarr); free((name)); (name) = NULL; } break; } while(0)

do{ FREEIM(grim) ;                                  \
      FREEIM(grim_showthru); } while(0) ;

( tempA_fvec3.xyz[0] = (v).xyz[0] * (A).mat[0][0]  \
                        +(v).xyz[1] * (A).mat[1][0]  \
                        +(v).xyz[2] * (A).mat[2][0] ,\
    tempA_fvec3.xyz[1] = (v).xyz[0] * (A).mat[0][1]  \
                        +(v).xyz[1] * (A).mat[1][1]  \
                        +(v).xyz[2] * (A).mat[2][1] ,\
    tempA_fvec3.xyz[2] = (v).xyz[0] * (A).mat[0][2]  \
                        +(v).xyz[1] * (A).mat[1][2]  \
                        +(v).xyz[2] * (A).mat[2][2] ,  tempA_fvec3 )

do{ GETSTR ; if(ISTARRED(str)) goto SkipSection ;    \
      strcpy(left,str) ;                               \
      GETSTR ; if(ISTARRED(str)) goto SkipSection ;    \
      strcpy(middle,str) ;                             \
      GETSTR ; if(ISTARRED(str)) goto SkipSection ;    \
      strcpy(right,str) ; } while(0)

do{ int nu=0,qq;                                                        \
      if( fptr-fbuf >= nbuf || fptr[0] == '\0' ) goto Finished ;          \
      str[0]='\0'; qq=sscanf(fptr,"%127s%n",str,&nu); nused+=nu;fptr+=nu; \
      if( str[0]=='\0' || qq==0 || nu==0 ) goto Finished ;                \
    } while(0)

do{ GETSSS ;                                                            \
      while(str[0]=='!' || (str[0]=='/' && str[1]=='/') ||                \
            (str[0]=='#' && str[1]=='\0') ){EOLSKIP; GETSSS;}             \
    } while(0)

do{ int iq ; (name) = (RENDER_state_array *) malloc(sizeof(RENDER_state_array)) ; \
         (name)->num = 0 ; (name)->nall = INC_RSA ;                                   \
         (name)->rsarr = (RENDER_state **)malloc(sizeof(RENDER_state *)*INC_RSA) ;   \
         for( iq=0 ; iq < INC_RSA ; iq++ ) (name)->rsarr[iq] = NULL ;               \
         break ; } while(0)

( ( (ds)->daxes->xxorient == ORI_L2R_TYPE ) && \
                            ( (ds)->daxes->yyorient == ORI_P2A_TYPE ) && \
                            ( (ds)->daxes->zzorient == ORI_I2S_TYPE )     )

( ( (ds)->daxes->xxorient == ORI_R2L_TYPE ) && \
                            ( (ds)->daxes->yyorient == ORI_A2P_TYPE ) && \
                            ( (ds)->daxes->zzorient == ORI_I2S_TYPE )     )

(void) XtVaCreateManagedWidget(                            \
            "dialog" , xmSeparatorWidgetClass , script_menu , \
             XmNseparatorType , XmSINGLE_LINE , NULL )

if( rs->nnn[0] != '\0' && RSDIFF_STR(nnn) ) \
      sss = THD_zzprintf( sss , "  " #nnn " = %s\n" , rs->nnn )

wname =                                                    \
         XtVaCreateManagedWidget(                              \
            "dialog" , xmPushButtonWidgetClass , script_menu , \
               LABEL_ARG( label ) ,                            \
               XmNmarginHeight , 0 ,                           \
               XmNtraversalOn , False ,                        \
               XmNinitialResourcesPersistent , False ,         \
            NULL ) ;                                           \
      XtAddCallback( wname , XmNactivateCallback ,             \
                     RCREND_script_CB , NULL ) ;

XtVaCreateManagedWidget(                     \
                       "AFNI" , xmSeparatorWidgetClass , (ww) ,   \
                          XmNseparatorType , XmSINGLE_LINE ,      \
                          XmNinitialResourcesPersistent , False , \
                       NULL )

XtVaCreateManagedWidget(                      \
                       "AFNI" , xmSeparatorWidgetClass , (ww) ,   \
                          XmNseparatorType , XmDOUBLE_LINE ,      \
                          XmNorientation   , XmVERTICAL ,         \
                          XmNinitialResourcesPersistent , False , \
                       NULL )

do{ XmString xstr ;                                              \
      xstr = XmStringCreateLtoR( NO_DATASET_STRING ,                \
                                 XmFONTLIST_DEFAULT_TAG ) ;          \
      XtVaSetValues( wfunc_info_lab , XmNlabelString,xstr , NULL ) ;  \
      XmStringFree(xstr) ;                                             \
                                                                        \
      xstr = RCREND_range_label() ;                                      \
      XtVaSetValues( wfunc_range_label , XmNlabelString , xstr , NULL ) ; \
      XmStringFree(xstr) ;                                                 \
                                                                            \
      xstr = RCREND_autorange_label() ;                                      \
      XtVaSetValues( wfunc_range_bbox->wbut[0], XmNlabelString,xstr, NULL ) ; \
      XmStringFree(xstr) ;                                                    \
                                                                             \
      AV_SENSITIZE( wfunc_color_av  , False ) ;                             \
      AV_SENSITIZE( wfunc_thresh_av , False ) ;                            \
  } while(0)

(( ISVALID_DSET(ds)                      )          && \
     ( DSET_INMEMORY(ds)                     )          && \
  \
     ( DSET_BRICK_TYPE(ds,0) == MRI_short ||               \
       DSET_BRICK_TYPE(ds,0) == MRI_byte  ||               \
      (DSET_BRICK_TYPE(ds,0) == MRI_float && float_ok))    \
             )

09329 {
09330     byte * bp = MRI_RGB_PTR(im);
09331     int    x, y;                        /* computed positions to plot    */
09332     int    x1, y1, x2, y2;              /* start and end positions       */
09333     int    xtot, ytot;                  /* cumulative directional steps  */
09334     int    xdir, ydir;                  /* direction of steps            */
09335     int    xsteps, ysteps, points;      /* total steps to make           */
09336     int    index;                       /* image index                   */
09337     int    pc;                          /* point counter                 */
09338 
09339 
09340 ENTRY( "draw_image_line" );
09341 
09342     x1 = (int)( p1->xyz[0] + im->nx / 2 + 0.001 );
09343     y1 = (int)( p1->xyz[1] + im->ny / 2 + 0.001 );
09344     x2 = (int)( p2->xyz[0] + im->nx / 2 + 0.001 );
09345     y2 = (int)( p2->xyz[1] + im->ny / 2 + 0.001 );
09346 
09347     if ( x1 == x2 && y1 == y2 )
09348         RETURN(0);
09349 
09350     BOUND_VAL( 0, x1, im->nx-1 );       /* just to be safe */
09351     BOUND_VAL( 0, y1, im->ny-1 );
09352     BOUND_VAL( 0, x2, im->nx-1 );
09353     BOUND_VAL( 0, y2, im->ny-1 );
09354 
09355     if ( x2 > x1 ) xdir =  1;
09356     else           xdir = -1;
09357 
09358     if ( y2 > y1 ) ydir =  1;
09359     else           ydir = -1;
09360 
09361     xsteps = abs(x2 - x1) + 1;
09362     ysteps = abs(y2 - y1) + 1;
09363     points = (xsteps >= ysteps) ? xsteps : ysteps;  /* points to plot */
09364 
09365     xtot = ytot = 0;
09366     for ( pc = 0; pc < points; pc++ )
09367     {
09368         x = x1 + xdir * (xtot/points);  /* hmmmm, that's a lot of work to  */
09369         y = y1 + ydir * (ytot/points);  /* allow arbitrary direction, alas */
09370 
09371         index = 3 * (x + y * im->nx);
09372 
09373         bp[index]   = rgb[0];
09374         bp[index+1] = rgb[1];
09375         bp[index+2] = rgb[2];
09376 
09377         xtot += xsteps;
09378         ytot += ysteps;
09379     }
09380 
09381     if ( gcr_debug.level > 0 )
09382     {
09383         printf( "++ drawing line from (%f,%f) to (%f,%f)\n",
09384                 p1->xyz[0], p1->xyz[1], p2->xyz[0], p2->xyz[1] );
09385         printf( "-- as line from (%d,%d) to (%d,%d)\n", x1, y1, x2, y2 );
09386     }
09387 
09388     RETURN(0);
09389 }

09301 {
09302     THD_fvec3 * p1, * p2;
09303     byte        rgb[3] = {0,0,0};
09304 
09305 ENTRY( "draw_xhairs_in_image" );
09306 
09307     if ( !x || !im )
09308         RETURN(-1);
09309 
09310     ovc_to_rgb_bytes( xhair_ovc, rgb, dc->ovc );
09311 
09312     draw_image_line( im, &x->xp[0][0], &x->xp[0][1], rgb );
09313     draw_image_line( im, &x->xp[1][0], &x->xp[1][1], rgb );
09314     draw_image_line( im, &x->yp[0][0], &x->yp[0][1], rgb );
09315     draw_image_line( im, &x->yp[1][0], &x->yp[1][1], rgb );
09316     draw_image_line( im, &x->zp[0][0], &x->zp[0][1], rgb );
09317     draw_image_line( im, &x->zp[1][0], &x->zp[1][1], rgb );
09318 
09319     RETURN(0);
09320 }

09041 {
09042     THD_dataxes * dax = dset->daxes;
09043     float         xi, yj, zk;
09044     float         fa, fb;
09045     int           om, gap;
09046 
09047 ENTRY( "get_xhair_points" );
09048 
09049     if ( ! pts || ! dset )
09050         RETURN(-1);
09051 
09052     xi = im3d->vinfo->xi;                       /* get Dicomm mm coords    */
09053     yj = im3d->vinfo->yj;
09054     zk = im3d->vinfo->zk;
09055 
09056     om  = im3d->vinfo->xhairs_orimask;          /* get xhair orient mask   */
09057     gap = im3d->vinfo->crosshair_gap;           /* get gap radius          */
09058 
09059     /* set the 2 x-direction xhair segments */
09060     if ( om & ORIMASK_LR )
09061     {
09062         /* first pair */
09063         fa = dax->xxorg;
09064         fb = xi - gap * dax->xxdel;
09065 
09066         LOAD_FVEC3( pts->xp[0][0], fa, yj, zk );
09067         LOAD_FVEC3( pts->xp[0][1], fb, yj, zk );
09068 
09069         if ( fb < fa )  /* stick to single endpoint */
09070             pts->xp[0][1] = pts->xp[0][0];
09071 
09072         /* second pair */
09073         fa = xi + gap * dax->xxdel;
09074         fb = dax->xxorg + dax->xxdel * (dax->nxx - 1);
09075 
09076         LOAD_FVEC3( pts->xp[1][0], fa, yj, zk );
09077         LOAD_FVEC3( pts->xp[1][1], fb, yj, zk );
09078 
09079         if ( fb < fa )  /* stick to single endpoint */
09080             pts->xp[1][0] = pts->xp[1][1];
09081     }
09082 
09083     /* set the 2 y-direction xhair segments */
09084     if ( om & ORIMASK_AP )
09085     {
09086         /* first pair */
09087         fa = dax->yyorg;
09088         fb = yj - gap * dax->yydel;
09089 
09090         LOAD_FVEC3( pts->yp[0][0], xi, fa, zk );
09091         LOAD_FVEC3( pts->yp[0][1], xi, fb, zk );
09092 
09093         if ( fb < fa )  /* stick to single endpoint */
09094             pts->yp[0][1] = pts->yp[0][0];
09095 
09096         /* second  pair */
09097         fa = yj + gap * dax->yydel;
09098         fb = dax->yyorg + dax->yydel * (dax->nyy - 1);
09099 
09100         LOAD_FVEC3( pts->yp[1][0], xi, fa, zk );
09101         LOAD_FVEC3( pts->yp[1][1], xi, fb, zk );
09102 
09103         if ( fb < fa )  /* stick to single endpoint */
09104             pts->yp[1][0] = pts->yp[1][1];
09105     }
09106 
09107     /* set the 2 z-direction xhair segments */
09108     if ( om & ORIMASK_IS )
09109     {
09110         /* first pair */
09111         fa = dax->zzorg;
09112         fb = zk - gap * dax->zzdel;
09113 
09114         LOAD_FVEC3( pts->zp[0][0], xi, yj, fa );
09115         LOAD_FVEC3( pts->zp[0][1], xi, yj, fb );
09116 
09117         if ( fb < fa )  /* stick to single endpoint */
09118             pts->zp[0][1] = pts->zp[0][0];
09119 
09120         /* second  pair */
09121         fa = zk + gap * dax->zzdel;
09122         fb = dax->zzorg + dax->zzdel * (dax->nzz - 1);
09123 
09124         LOAD_FVEC3( pts->zp[1][0], xi, yj, fa );
09125         LOAD_FVEC3( pts->zp[1][1], xi, yj, fb );
09126 
09127         if ( fb < fa )  /* stick to single endpoint */
09128             pts->zp[1][0] = pts->zp[1][1];
09129     }
09130 
09131     /* debug stuff */
09132     LOAD_FVEC3( gcr_debug.xhairs, xi, yj, zk );         /* save for later */
09133 
09134     if ( gcr_debug.level > 0 )
09135         r_idisp_vec3f( "-- xhair center : ", gcr_debug.xhairs.xyz );
09136 
09137     RETURN(0);
09138 }

00758   {
00759      GRAF_get_setup( gp , &(gs->nh) , gs->xh , gs->yh , &(gs->spl) ) ;
00760      return ;
00761   }

00764   {
00765      GRAF_put_setup( gp , gs->nh , gs->xh , gs->yh , gs->spl ) ;
00766      return ;
00767   }

00747   {  int ii ;
00748      if( g1->nh  != g2->nh  ) return 0 ;
00749      if( g1->spl != g2->spl ) return 0 ;
00750      for( ii=0 ; ii < g1->nh ; ii++ ){
00751         if( g1->xh[ii] != g2->xh[ii] ) return 0 ;
00752         if( g1->yh[ii] != g2->yh[ii] ) return 0 ;
00753      }
00754      return 1 ;
00755   }

09277 {
09278     if ( ! p )
09279     {
09280         fputs( "idisp_xhair_pts: p == NULL!\n", stderr );
09281         return;
09282     }
09283 
09284     r_idisp_vec3f( note, p->xp[0][0].xyz );
09285     r_idisp_vec3f( note, p->xp[0][1].xyz );
09286     r_idisp_vec3f( note, p->xp[1][0].xyz );
09287     r_idisp_vec3f( note, p->xp[1][1].xyz );
09288 
09289     r_idisp_vec3f( note, p->yp[0][0].xyz );
09290     r_idisp_vec3f( note, p->yp[0][1].xyz );
09291     r_idisp_vec3f( note, p->yp[1][0].xyz );
09292     r_idisp_vec3f( note, p->yp[1][1].xyz );
09293 
09294     r_idisp_vec3f( note, p->zp[0][0].xyz );
09295     r_idisp_vec3f( note, p->zp[0][1].xyz );
09296     r_idisp_vec3f( note, p->zp[1][0].xyz );
09297     r_idisp_vec3f( note, p->zp[1][1].xyz );
09298 }

09572 {
09573     BOUND_VAL( 0, ovc, ov->ncol_ov );
09574 
09575     if ( ovc == 0 )     /* then use white */
09576     {
09577         rgb[0] = 255;
09578         rgb[1] = 255;
09579         rgb[2] = 255;
09580     }
09581     else
09582     {
09583         /* get the intensities from the color map */
09584         rgb[0] = ov->r_ov[ovc];
09585         rgb[1] = ov->g_ov[ovc];
09586         rgb[2] = ov->b_ov[ovc];
09587     }
09588 
09589     if ( gcr_debug.level > 0 )
09590         printf( "-- rgb vals are %d, %d, %d\n", rgb[0], rgb[1], rgb[2] );
09591 
09592     return 1;
09593 }

00172 {
00173    char * env ;
00174    float  val ;
00175 
00176    if( ncall > 0 ) return(NULL);  /* only one interface */
00177 
00178    plint = PLUTO_new_interface( "Render [new]" , NULL , NULL ,
00179                                 PLUGIN_CALL_IMMEDIATELY , RCREND_main ) ;
00180 
00181    PLUTO_add_hint( plint , "Volume Rendering" ) ;
00182 
00183    PLUTO_set_sequence( plint , "A:graphics" ) ;
00184 
00185    /***----- retrieve relevant environment variables, if any -----***/
00186 
00187    env = getenv("AFNI_RENDER_ANGLE_DELTA") ;
00188    if( env != NULL ){
00189       val = strtod(env,NULL) ;
00190       if( val > 0.0 && val < 100.0 ) angle_fstep = val ;
00191    }
00192    PLUTO_register_environment_numeric( "AFNI_RENDER_ANGLE_DELTA" ,
00193                                        "Angle stepsize in deg (volume renderer)" ,
00194                                        1,9,0,(int)angle_fstep, RCREND_environ_CB );
00195 
00196    /*--*/
00197 
00198    env = getenv("AFNI_RENDER_CUTOUT_DELTA") ;
00199    if( env != NULL ){
00200       val = strtod(env,NULL) ;
00201       if( val > 0.0 && val < 100.0 ) cutout_fstep = val ;
00202    }
00203    PLUTO_register_environment_numeric( "AFNI_RENDER_CUTOUT_DELTA" ,
00204                                        "Cutout stepsize in mm (volume renderer)" ,
00205                                        1,9,0,(int)cutout_fstep, RCREND_environ_CB );
00206 
00207 #if 0      /* 2002 Mar 06 : showthru factor has moved to the plugin GUI */
00208    env = getenv("AFNI_RENDER_SHOWTHRU_FAC") ;
00209    if( env != NULL ){
00210       val = strtod(env,NULL) ;
00211       if( val < 0.0 || val > 1.0 ) val = 1.0 ;
00212    } else {
00213       val = 1.0 ;
00214    }
00215    PLUTO_register_environment_numeric( "AFNI_RENDER_SHOWTHRU_FAC" ,
00216                                        "ShowThru mixing factor (volume renderer)",
00217                                        30,100,2,(int)rint(100.0*val) , NULL ) ;
00218 #endif
00219 
00220    /*-- done --*/
00221 
00222    return(plint);
00223 }

09410 {
09411     char * sp = str;
09412     int    choice;
09413 
09414 ENTRY( "r_debug_check" );
09415 
09416     /* check to see if we have a valid debug request */
09417     if ( ! d   )         RETURN(0);
09418     if ( ! sp )          RETURN(0);
09419     if ( isspace(*sp) )  sp++;         /* allow a single leading space */
09420     if ( *sp++ != 'd' )  RETURN(0);
09421 
09422     choice = rd_debug_choice( &sp );  /* so get past choice character(s) */
09423 
09424     switch ( choice )
09425     {
09426         case RD_CHOICE_HELP:        rd_disp_debug_help(sp,d);            break;
09427         case RD_CHOICE_HIST:        fputs(g_cren_hist, stderr);          break;
09428         case RD_CHOICE_DISP_COLORS: rd_disp_color_info(sp,d,&gcr);       break;
09429         case RD_CHOICE_DISP_DSET:   rd_disp_dset_info (sp,d,&gcr);       break;
09430         case RD_CHOICE_DISP_IM:     rd_disp_mri_image (sp,d,renderings); break;
09431         case RD_CHOICE_SET_LEVEL:   rd_set_debug_level(sp,d);            break;
09432         case RD_CHOICE_DISP_XHAIRS: rd_disp_xhairs    (sp,d);            break;
09433 
09434         default:
09435              printf( "error: invalid debug command: %5s\n", str );       break;
09436     }
09437 
09438     fflush(stdout);
09439 
09440     RETURN(1);  /* we did something */
09441 }

08893 {
08894     unsigned char * tmpi = im;
08895     unsigned char   max = 0;
08896     int             c1, s1, s2, cur;
08897 
08898 ENTRY( "rcr_disp_hist" );
08899 
08900     if ( ( b1 > 256 ) || ( b2 > 256 ) || ( im == NULL ) )
08901     {
08902         fprintf( stderr, "*** incorrect parameters to rcr_disp_hist\n" );
08903         EXRETURN;
08904     }
08905 
08906     memset( grcr_hist_high, 0, 256 * sizeof(int) );
08907     memset( grcr_hist_low, 0, 256 * sizeof(int) );
08908 
08909     for ( c1 = 0, tmpi = im; c1 < nvox; c1++, tmpi++ )
08910         if ( *tmpi > max )
08911             max = *tmpi;
08912 
08913     s1 = (b1 <= 0) ? 1 : (cut+b1-1) / b1;
08914     s2 = (b2 <= 0) ? 1 : (max - cut + b2) / b2;   /* m+1-c+b2-1 */
08915 
08916     for ( c1 = 0, tmpi = im; c1 < nvox; c1++, tmpi++ )
08917     {
08918         if ( *tmpi >= cut )
08919             grcr_hist_high[(*tmpi - cut) / s2]++;
08920         else
08921             grcr_hist_low[*tmpi / s1]++;
08922     }
08923 
08924     printf( "nvox = %d, max = %d\n", nvox, max );
08925 
08926     cur = 0;
08927     if ( cut && b1 )
08928     {
08929         printf( "--------- lower buckets ---------\n" );
08930         for (c1 = 0; c1 < b1; c1++)
08931         {
08932             printf( "[%d,%d] : %d\n", cur, cur + s1 - 1, grcr_hist_low[c1] );
08933             cur += s1;
08934         }
08935     }
08936 
08937     cur = cut;
08938     printf( "--------- upper buckets ---------\n" );
08939     for (c1 = 0; c1 < b2; c1++)
08940     {
08941         printf( "[%d,%d] : %d\n", cur, cur + s2 - 1, grcr_hist_high[c1] );
08942         cur += s2;
08943     }
08944 
08945     EXRETURN;
08946 }

04031 {
04032 ENTRY( "RCREND_accum_CB" );
04033 
04034    accum_flag = MCW_val_bbox( accum_bbox ) ;
04035    EXRETURN ;
04036 }

03999 {
04000    if( cbs != NULL && cbs->reason == mcwCR_string && cbs->cval != NULL ){
04001      MCW_strncpy( accum_label , cbs->cval , 255 ) ;
04002 
04003      if( accum_lab_replace && renderings != NULL && imseq != NULL ){
04004        int nn=-1 ; MRI_IMAGE *rim ;
04005        drive_MCW_imseq( imseq , isqDR_getimnr , (XtPointer)&nn ) ;
04006        if( nn >= 0 && nn < IMARR_COUNT(renderings) ){
04007          MRI_IMAGE *rim = IMARR_SUBIM(renderings,nn) ;
04008          mri_add_name( accum_label , rim ) ;
04009          drive_MCW_imseq( imseq , isqDR_display , (XtPointer)nn ) ;
04010        }
04011      }
04012    }
04013    return ;
04014 }

03974 {
03975 ENTRY( "RCREND_accum_lab_EV" );
03976 
03977    switch( ev->type ){
03978       case ButtonPress:{
03979          XButtonEvent *event = (XButtonEvent *) ev ;
03980 
03981          if( event->button == Button3 || event->button == Button2 ){
03982            char *ttl ;
03983            accum_lab_replace =
03984              ( (event->state & ShiftMask) || (event->state & ControlMask) ) ;
03985 
03986            ttl = (accum_lab_replace) ? "Replacment Label"
03987                                      : "New Overlay Label" ;
03988            MCW_choose_string( w,ttl,accum_label , RCREND_accum_lab_CB,NULL ) ;
03989          }
03990       }
03991       break ;
03992    }
03993    EXRETURN ;
03994 }

03658 {
03659    float na ;
03660 
03661 ENTRY( "RCREND_angle_CB" );
03662 
03663 /*==========================================================================*/
03664 #ifdef ALLOW_INCROT  /* 26 Apr 2002 - RWCox */
03665    if( cd == NULL && MCW_val_bbox(incrot_bbox) ){  /* increment mode  */
03666       RCREND_do_incrot( av ) ;                     /* ==> do work here */
03667       EXRETURN ;
03668    }
03669 #endif
03670 /*==========================================================================*/
03671 
03672    if( av == roll_av  ){
03673 
03674       na = angle_roll = av->fval ;
03675            if( na <    0.0 ) na += 360 ;
03676       else if( na >= 360.0 ) na -= 360.0 ;
03677       if( na != av->fval ){ AV_assign_fval( av , na ) ; angle_roll = na ; }
03678 
03679    } else if( av == pitch_av ){
03680 
03681      na = angle_pitch = av->fval ;
03682            if( na <    0.0 ) na += 360 ;
03683       else if( na >= 360.0 ) na -= 360.0 ;
03684       if( na != av->fval ){ AV_assign_fval( av , na ) ; angle_pitch = na ; }
03685 
03686    } else if( av == yaw_av   ){
03687 
03688       na = angle_yaw = av->fval ;
03689            if( na <    0.0 ) na += 360 ;
03690       else if( na >= 360.0 ) na -= 360.0 ;
03691       if( na != av->fval ){ AV_assign_fval( av , na ) ; angle_yaw = na ; }
03692 
03693    } else {
03694       EXRETURN ;  /* should never happen */
03695    }
03696 
03697    if( cd == NULL && dynamic_flag && gcr.rh != NULL )
03698       RCREND_draw_CB(NULL,NULL,NULL) ;
03699 
03700    EXRETURN ;
03701 }

05161 {
05162 ENTRY( "RCREND_autocancel_CB" );
05163 
05164    if( autokill ){ XBell(dc->display,100) ; EXRETURN ; }
05165    autokill = 1 ;
05166 
05167    EXRETURN;
05168 }

05107 {
05108    int it , ntime = autoframe_av->ival ;
05109    float scl = 100.0/ntime ;
05110    Widget autometer ;
05111 
05112 ENTRY( "RCREND_autocompute_CB" );
05113 
05114    automate_flag = 1 ;
05115    if( ! accum_flag ){
05116       DESTROY_IMARR(renderings) ;
05117 #ifdef USE_SCRIPTING
05118       DESTROY_RSA(renderings_state) ;
05119 #endif
05120    }
05121 
05122    atoz[N_IND] = ntime ;
05123 
05124    autometer = MCW_popup_meter( shell , METER_TOP_WIDE ) ;
05125 
05126    XtManageChild( autocancel_pb ) ; AFNI_add_interruptable( autocancel_pb ) ;
05127    autokill = 0 ;
05128 
05129    for( it=0 ; it < ntime ; it++ ){
05130       atoz[T_IND] = it ;
05131       AV_assign_ival( autoframe_av , it+1 ) ;
05132 
05133       RCREND_draw_CB(NULL,NULL,NULL) ;
05134 
05135       if( it < ntime-1 ){
05136          AFNI_process_interrupts(autocancel_pb) ;
05137          if( autokill ) break ;
05138       }
05139 
05140       MCW_set_meter( autometer , (int)(scl*(it+1)) ) ;
05141    }
05142 
05143    MCW_popdown_meter( autometer ) ;
05144 
05145    /*-- done: turn off automation --*/
05146 
05147    MCW_set_bbox( automate_bbox , 0 ) ;
05148    XtSetSensitive( autocompute_pb , False ) ;
05149 
05150    XtUnmanageChild( autocancel_pb ) ; AFNI_add_interruptable(NULL) ;
05151 
05152    automate_flag = 0 ;
05153    EXRETURN ;
05154 }

05087 {
05088    int flag = MCW_val_bbox( automate_bbox ) ;
05089 ENTRY( "RCREND_autoflag_CB" );
05090 
05091    XtSetSensitive( autocompute_pb , (Boolean) flag ) ;
05092 
05093 #ifdef ALLOW_INCROT  /* 26 Apr 2002 - RWCox */
05094    if( flag ) MCW_set_bbox( incrot_bbox , 0 ) ;
05095 #endif
05096 
05097    EXRETURN ;
05098 }

06201 {
06202    XmString xstr ;
06203    float rrr = DEFAULT_FUNC_RANGE ;
06204    char buf[32] , qbuf[16] ;
06205 
06206 ENTRY( "RCREND_autorange_label" );
06207 
06208    if( ISVALID_DSET(func_dset) ){
06209 
06210       RELOAD_STATS(func_dset) ;
06211       if( ISVALID_STATISTIC(func_dset->stats) ){
06212          float s1 , s2 ; int iv ;
06213 
06214          iv = func_color_ival ;
06215 
06216          if( DSET_VALID_BSTAT(func_dset,iv) ){
06217             s1  = fabs(func_dset->stats->bstat[iv].min) ,
06218             s2  = fabs(func_dset->stats->bstat[iv].max) ;
06219             rrr = (s1<s2) ? s2 : s1 ;
06220             if( rrr == 0.0 ) rrr = 1.0 ;
06221          }
06222       }
06223    }
06224 
06225    func_autorange = rrr ;
06226    AV_fval_to_char( rrr , qbuf ) ;
06227    sprintf( buf , "autoRange:%s" , qbuf ) ;
06228    xstr = XmStringCreateLtoR( buf , XmFONTLIST_DEFAULT_TAG ) ;
06229 
06230    RETURN(xstr);
06231 }

05175 {
05176    XmString xstr ;
05177    char str[2*THD_MAX_NAME] ;
05178 
05179 ENTRY( "RCREND_choose_av_CB" );
05180 
05181    /*--- selection of an underlay sub-brick ---*/
05182 
05183    if( av == choose_av && dset != NULL && av->ival < DSET_NVALS(dset) ){
05184 
05185       float fac = DSET_BRICK_FACTOR(dset,av->ival) ;
05186 
05187       if( fac == 0.0 || fac == 1.0 ){  /* rewrite the informational label */
05188          strcpy(str,dset_title) ;
05189       } else {
05190          char abuf[16] ;
05191          AV_fval_to_char( fac , abuf ) ;
05192          sprintf(str,"%s [* %s]", dset_title , abuf ) ;
05193       }
05194       xstr = XmStringCreateLtoR( str , XmFONTLIST_DEFAULT_TAG ) ;
05195       XtVaSetValues( info_lab , XmNlabelString , xstr , NULL ) ;
05196       XmStringFree(xstr) ;
05197 
05198       dset_ival = av->ival ;   /* read this sub-brick    */
05199       new_dset = 1 ;           /* flag it as new         */
05200       FREE_VOLUMES ;           /* free the internal data */
05201       RCREND_reload_dataset() ;  /* load the data          */
05202 
05203       if( gcr.rh != NULL ) RCREND_draw_CB(NULL,NULL,NULL) ; /* draw */
05204 
05205    /*--- selection of overlay color sub-brick ---*/
05206 
05207    } else if( av == wfunc_color_av && func_dset != NULL && av->ival < DSET_NVALS(func_dset) ){
05208 
05209       float fac = DSET_BRICK_FACTOR(func_dset,av->ival) ;
05210 
05211       if( fac == 0.0 || fac == 1.0 ){  /* rewrite the informational label */
05212          strcpy(str,func_dset_title) ;
05213       } else {
05214          char abuf[16] ;
05215          AV_fval_to_char( fac , abuf ) ;
05216          sprintf(str,"%s [* %s]", func_dset_title , abuf ) ;
05217       }
05218       xstr = XmStringCreateLtoR( str , XmFONTLIST_DEFAULT_TAG ) ;
05219       XtVaSetValues( wfunc_info_lab , XmNlabelString , xstr , NULL ) ;
05220       XmStringFree(xstr) ;
05221 
05222       func_color_ival = av->ival ;
05223 
05224       /* fix the range labels */
05225 
05226       xstr = RCREND_range_label() ;
05227       XtVaSetValues( wfunc_range_label , XmNlabelString , xstr , NULL ) ;
05228       XmStringFree(xstr) ;
05229 
05230       xstr = RCREND_autorange_label() ;
05231       XtVaSetValues( wfunc_range_bbox->wbut[0], XmNlabelString,xstr , NULL ) ;
05232       XmStringFree(xstr) ;
05233 
05234       new_fset = 1 ;           /* flag it as new - may resample new sub-brick */
05235       INVALIDATE_OVERLAY ;
05236 
05237       AFNI_hintize_pbar( wfunc_color_pbar , FUNC_RANGE ) ; /* 30 Jul 2001 */
05238 
05239    /*--- selection of overlay threshold sub-brick ---*/
05240 
05241    } else if( av == wfunc_thresh_av && func_dset != NULL && av->ival < DSET_NVALS(func_dset) ){
05242 
05243       func_thresh_ival = av->ival ;
05244 
05245       /* fix the range label */
05246 
05247       xstr = RCREND_range_label() ;
05248       XtVaSetValues( wfunc_range_label , XmNlabelString , xstr , NULL ) ;
05249       XmStringFree(xstr) ;
05250 
05251       /* fix the p-value label */
05252 
05253       RCREND_set_thr_pval() ;
05254 
05255       new_fset = 1 ;           /* flag it as new - may resample new sub-brick */
05256       INVALIDATE_OVERLAY ;
05257    }
05258 
05259    EXRETURN ;
05260 }

05267 {
05268    static char blab[32] ;
05269    THD_3dim_dataset * dset = (THD_3dim_dataset *) cd ;
05270    static char * lfmt[3] = { "#%1d %-14.14s" , "#%2d %-14.14s" , "#%3d %-14.14s"  } ;
05271    static char * rfmt[3] = { "%-14.14s #%1d" , "%-14.14s #%2d" , "%-14.14s #%3d"  } ;
05272 
05273 ENTRY( "RCREND_choose_av_label_CB" );
05274 
05275    if( ISVALID_3DIM_DATASET(dset) ){
05276 
05277 #ifdef USE_RIGHT_BUCK_LABELS
05278       if( DSET_NVALS(dset) < 10 )
05279         sprintf(blab, rfmt[0] , DSET_BRICK_LABEL(dset,av->ival) , av->ival ) ;
05280       else if( DSET_NVALS(dset) < 100 )
05281         sprintf(blab, rfmt[1] , DSET_BRICK_LABEL(dset,av->ival) , av->ival ) ;
05282       else
05283         sprintf(blab, rfmt[2] , DSET_BRICK_LABEL(dset,av->ival) , av->ival ) ;
05284 #else
05285       if( DSET_NVALS(dset) < 10 )
05286         sprintf(blab, lfmt[0] , av->ival , DSET_BRICK_LABEL(dset,av->ival) ) ;
05287       else if( DSET_NVALS(dset) < 100 )
05288         sprintf(blab, lfmt[1] , av->ival , DSET_BRICK_LABEL(dset,av->ival) ) ;
05289       else
05290         sprintf(blab, lfmt[2] , av->ival , DSET_BRICK_LABEL(dset,av->ival) ) ;
05291 #endif
05292    }
05293    else
05294       sprintf(blab," #%d ",av->ival) ;  /* should not happen! */
05295 
05296    RETURN(blab) ;
05297 }

03322 {
03323    int vv = im3d->vinfo->view_type ; /* view type */
03324    THD_3dim_dataset * qset ;
03325    int id , ltop , llen , dofunc ;
03326    char qnam[THD_MAX_NAME] , label[THD_MAX_NAME] ;
03327    static char ** strlist = NULL ;
03328 
03329    int isl = -2 ;     /* 03 Apr 1999 */
03330    MCW_idcode midc ;
03331 
03332 ENTRY( "RCREND_choose_CB" );
03333 
03334    /*-- decide if we want overlay (func) or underlay --*/
03335 
03336    dofunc = (w == wfunc_choose_pb) ;
03337 
03338    if( dofunc && !ISVALID_DSET(dset) ){
03339       (void) MCW_popup_message( w ,
03340                                    "Can't choose overlay\nbefore underlay!" ,
03341                                 MCW_USER_KILL | MCW_TIMER_KILL ) ;
03342       XBell(dc->display,100) ; EXRETURN ;
03343    }
03344 
03345    if( dofunc )
03346       RCREND_load_dsl( dset , 1 ) ;
03347    else
03348       RCREND_load_dsl( NULL , 0 ) ;
03349 
03350    /* found nothing?  exit */
03351 
03352    if( ndsl < 1 ){
03353       (void) MCW_popup_message( w ,
03354                                    "Didn't find\nany datasets\nto render!" ,
03355                                 MCW_USER_KILL | MCW_TIMER_KILL ) ;
03356       XBell(dc->display,100) ; EXRETURN ;
03357    }
03358 
03359    /*--- loop over dataset links and patch their titles
03360          to include an indicator of the dataset type    ---*/
03361 
03362    ltop = 4 ;
03363    for( id=0 ; id < ndsl ; id++ ){
03364       llen = strlen(dsl[id].title) ;
03365       ltop = MAX(ltop,llen) ;
03366    }
03367 
03368    for( id=0 ; id < ndsl ; id++ ){
03369       qset = PLUTO_find_dset( &(dsl[id].idcode) ) ;
03370       if( ! ISVALID_DSET(qset) ) continue ;
03371       if( ISANAT(qset) ){
03372          if( ISANATBUCKET(qset) )         /* 30 Nov 1997 */
03373             sprintf(qnam,"%-*s [%s:%d]" ,
03374                     ltop,dsl[id].title ,
03375                     ANAT_prefixstr[qset->func_type] , DSET_NVALS(qset) ) ;
03376 
03377          else if( DSET_NUM_TIMES(qset) == 1 )
03378             sprintf(qnam,"%-*s [%s]" ,
03379                     ltop,dsl[id].title ,
03380                     ANAT_prefixstr[qset->func_type] ) ;
03381 
03382          else
03383             sprintf(qnam,"%-*s [%s:3D+t:%d]" ,
03384                     ltop,dsl[id].title ,
03385                     ANAT_prefixstr[qset->func_type] , DSET_NUM_TIMES(qset) ) ;
03386 
03387       } else {
03388          if( ISFUNCBUCKET(qset) )         /* 30 Nov 1997 */
03389             sprintf(qnam,"%-*s [%s:%d]" ,
03390                     ltop,dsl[id].title ,
03391                     FUNC_prefixstr[qset->func_type] , DSET_NVALS(qset) ) ;
03392 
03393          else if( DSET_NUM_TIMES(qset) == 1 )
03394             sprintf(qnam,"%-*s [%s]" ,
03395                     ltop,dsl[id].title ,
03396                     FUNC_prefixstr[qset->func_type] ) ;
03397 
03398          else
03399             sprintf(qnam,"%-*s [%s:3D+t:%d]" ,
03400                     ltop,dsl[id].title ,
03401                     FUNC_prefixstr[qset->func_type] , DSET_NVALS(qset) ) ;
03402       }
03403 
03404       if( DSET_COMPRESSED(qset) ) strcat(qnam,"z") ;
03405 
03406       strcpy( dsl[id].title , qnam ) ;
03407    }
03408 
03409    /*--- make a popup chooser for the user to browse ---*/
03410 
03411    POPDOWN_strlist_chooser ;
03412 
03413    strlist = (char **) XtRealloc( (char *)strlist , sizeof(char *)*ndsl ) ;
03414    for( id=0 ; id < ndsl ; id++ ) strlist[id] = dsl[id].title ;
03415 
03416    /*-- 03 Apr 1999: set the initial selection in the chooser --*/
03417 
03418         if(  dofunc && func_dset != NULL ){ midc = func_dset_idc; isl = -1; }
03419    else if( !dofunc && dset      != NULL ){ midc = dset_idc     ; isl = -1; }
03420 
03421    if( isl == -1 ){
03422       for( id=0 ; id < ndsl ; id++ ){
03423          if( EQUIV_IDCODES(midc,dsl[id].idcode) ){ isl = id ; break ; }
03424       }
03425    }
03426 
03427    /*-- popup the chooser -- */
03428 
03429    sprintf( label , "AFNI Dataset from\nthe %s" , VIEW_typestr[vv] ) ;
03430 
03431    MCW_choose_strlist( w , label , ndsl , isl , strlist ,
03432                        (dofunc) ? RCREND_finalize_func_CB
03433                                 : RCREND_finalize_dset_CB , NULL ) ;
03434    EXRETURN ;
03435 }