00001 /*****************************************************************************
00002    Major portions of this software are copyrighted by the Medical College
00003    of Wisconsin, 1994-2000, and are released under the Gnu General Public
00004    License, Version 2.  See the file README.Copyright for details.
00005 ******************************************************************************/
00006 
00007 #include "mrilib.h"
00008 
00009 #undef ROUND
00010 #define ROUND(qq)   rint((qq))
00011 
00012 /*------------------------------------------------------------------------
00013   convert one volume to another type
00014      nxy   = # voxels
00015      itype = input datum type
00016      ivol  = pointer to input volume
00017      otype = output datum type
00018      ovol  = pointer to output volume (must have space allocated already!)
00019 --------------------------------------------------------------------------*/
00020 
00021 void EDIT_coerce_type( int nxyz , int itype,void *ivol , int otype,void *ovol )
00022 {
00023    register int ii ;
00024 
00025    complex * cin , * cout ;
00026    short   * sin , * sout ;
00027    float   * fin , * fout ;
00028    byte    * bin , * bout ;
00029    double  * din , * dout ;  /* 10 Jan 1999 */
00030 
00031 ENTRY("EDIT_coerce_type") ;
00032 #ifdef AFNI_DEBUG
00033 { char str[256] ;
00034   sprintf(str,"voxels=%d input type=%s output type=%s",
00035           nxyz, MRI_TYPE_name[itype],MRI_TYPE_name[otype]) ;
00036   STATUS(str) ; }
00037 #endif
00038 
00039    if( nxyz <= 0 || ivol == NULL || ovol == NULL ) EXRETURN ;
00040 
00041    switch( itype ){
00042       default:
00043         fprintf(stderr,"** Unknown itype=%d in EDIT_coerce_type\n",itype);
00044       EXRETURN ;
00045       case MRI_complex:  cin = (complex *) ivol ; break ;
00046       case MRI_short  :  sin = (short   *) ivol ; break ;
00047       case MRI_float  :  fin = (float   *) ivol ; break ;
00048       case MRI_byte   :  bin = (byte    *) ivol ; break ;
00049       case MRI_double :  din = (double  *) ivol ; break ;
00050    }
00051    switch( otype ){
00052       default:
00053         fprintf(stderr,"** Unknown otype=%d in EDIT_coerce_type\n",otype);
00054       EXRETURN ;
00055       case MRI_complex:  cout = (complex *) ovol ; break ;
00056       case MRI_short  :  sout = (short   *) ovol ; break ;
00057       case MRI_float  :  fout = (float   *) ovol ; break ;
00058       case MRI_byte   :  bout = (byte    *) ovol ; break ;
00059       case MRI_double :  dout = (double  *) ovol ; break ;
00060    }
00061 
00062    switch( otype ){
00063 
00064       /*** outputs are shorts ***/
00065 
00066       case MRI_short:
00067          switch( itype ){
00068             case MRI_short:   /* inputs are shorts */
00069                memcpy( sout , sin , sizeof(short)*nxyz ) ;
00070                EXRETURN ;
00071             case MRI_float:   /* inputs are floats */
00072                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fin[ii]) ;
00073                EXRETURN ;
00074             case MRI_double:   /* inputs are doubles */
00075                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(din[ii]) ;
00076                EXRETURN ;
00077             case MRI_byte:    /* inputs are bytes */
00078                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = bin[ii] ;
00079                EXRETURN ;
00080             case MRI_complex:    /* inputs are complex */
00081                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(CABS(cin[ii])) ;
00082                EXRETURN ;
00083          }
00084          EXRETURN ;
00085 
00086       /*** outputs are floats ***/
00087 
00088       case MRI_float:
00089          switch( itype ){
00090             case MRI_short:   /* inputs are shorts */
00091                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = sin[ii] ;
00092                EXRETURN ;
00093             case MRI_float:   /* inputs are floats */
00094                memcpy( fout , fin , sizeof(float)*nxyz ) ;
00095                EXRETURN ;
00096             case MRI_double:    /* inputs are doubles */
00097                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = din[ii] ;
00098                EXRETURN ;
00099             case MRI_byte:    /* inputs are bytes */
00100                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = bin[ii] ;
00101                EXRETURN ;
00102             case MRI_complex:    /* inputs are complex */
00103                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = CABS(cin[ii]) ;
00104                EXRETURN ;
00105          }
00106          EXRETURN ;
00107 
00108       /*** outputs are doubles ***/
00109 
00110       case MRI_double:
00111          switch( itype ){
00112             case MRI_short:   /* inputs are shorts */
00113                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = sin[ii] ;
00114                EXRETURN ;
00115             case MRI_float:   /* inputs are floats */
00116                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fin[ii] ;
00117                EXRETURN ;
00118             case MRI_double:   /* inputs are doubles */
00119                memcpy( dout , din , sizeof(double)*nxyz ) ;
00120                EXRETURN ;
00121             case MRI_byte:    /* inputs are bytes */
00122                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = bin[ii] ;
00123                EXRETURN ;
00124             case MRI_complex:    /* inputs are complex */
00125                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = CABS(cin[ii]) ;
00126                EXRETURN ;
00127          }
00128          EXRETURN ;
00129 
00130       /*** outputs are bytes ***/
00131 
00132       case MRI_byte:
00133          switch( itype ){
00134             case MRI_short:   /* inputs are shorts */
00135                for( ii=0 ; ii < nxyz ; ii++ ) bout[ii] = SHORT_TO_BYTE(sin[ii]) ;
00136                EXRETURN ;
00137             case MRI_float:   /* inputs are floats */
00138                for( ii=0 ; ii < nxyz ; ii++ ) bout[ii] = FLOAT_TO_BYTE(fin[ii]) ;
00139                EXRETURN ;
00140             case MRI_double:   /* inputs are doubles */
00141                for( ii=0 ; ii < nxyz ; ii++ ) bout[ii] = FLOAT_TO_BYTE(din[ii]) ;
00142                EXRETURN ;
00143             case MRI_byte:    /* inputs are bytes */
00144                memcpy( bout , bin , sizeof(byte)*nxyz ) ;
00145                EXRETURN ;
00146             case MRI_complex:{    /* inputs are complex */
00147                float val ;
00148                for( ii=0 ; ii < nxyz ; ii++ ){ val = CABS(cin[ii]) ;
00149                                                bout[ii] = FLOAT_TO_BYTE(val) ; }
00150             }
00151             EXRETURN ;
00152          }
00153          EXRETURN ;
00154 
00155       /*** outputs are complex ***/
00156 
00157       case MRI_complex:
00158          switch( itype ){
00159             case MRI_short:   /* inputs are shorts */
00160                for( ii=0 ; ii < nxyz ; ii++ )
00161                   cout[ii].r = sin[ii] , cout[ii].i = 0.0 ;
00162                EXRETURN ;
00163             case MRI_float:   /* inputs are floats */
00164                for( ii=0 ; ii < nxyz ; ii++ )
00165                   cout[ii].r = fin[ii] , cout[ii].i = 0.0 ;
00166                EXRETURN ;
00167             case MRI_double:   /* inputs are doubles */
00168                for( ii=0 ; ii < nxyz ; ii++ )
00169                   cout[ii].r = din[ii] , cout[ii].i = 0.0 ;
00170                EXRETURN ;
00171             case MRI_byte:    /* inputs are bytes */
00172                for( ii=0 ; ii < nxyz ; ii++ )
00173                   cout[ii].r = bin[ii] , cout[ii].i = 0.0 ;
00174                EXRETURN ;
00175             case MRI_complex:    /* inputs are complex */
00176                memcpy( cout , cin , sizeof(complex)*nxyz ) ;
00177                EXRETURN ;
00178          }
00179          EXRETURN ;
00180    }
00181    EXRETURN ;
00182 }
00183 
00184 /*------------------------------------------------------------------------
00185   convert one volume to another type, scaling as we go
00186      nxyz  = # voxels
00187      scl   = scale factor (if zero, same as calling EDIT_coerce_type)
00188      itype = input datum type
00189      ivol  = pointer to input volume
00190      otype = output datum type
00191      ovol  = pointer to output volume (again, must be pre-malloc-ed)
00192 --------------------------------------------------------------------------*/
00193 
00194 void EDIT_coerce_scale_type( int nxyz , float scl ,
00195                              int itype,void *ivol , int otype,void *ovol )
00196 {
00197    register int ii ;
00198    register float fac = scl , val ;
00199 
00200    complex * cin , * cout ;
00201    short   * sin , * sout ;
00202    float   * fin , * fout ;
00203    byte    * bin , * bout ;
00204    double  * din , * dout ;   /* 11 Jan 1999 */
00205 
00206 ENTRY("EDIT_coerce_scale_type") ;
00207 #ifdef AFNI_DEBUG
00208 { char str[256] ;
00209   sprintf(str,"voxels=%d scale=%g input type=%s output type=%s",
00210           nxyz,scl , MRI_TYPE_name[itype],MRI_TYPE_name[otype]) ;
00211   STATUS(str) ; }
00212 #endif
00213 
00214    if( nxyz <= 0 || ivol == NULL || ovol == NULL ) EXRETURN ;
00215 
00216    if( fac == 0.0 || fac == 1.0 ){
00217       EDIT_coerce_type( nxyz , itype,ivol , otype,ovol ) ;
00218       EXRETURN ;
00219    }
00220 
00221    switch( itype ){
00222       default:
00223         fprintf(stderr,"** Unknown itype=%d in EDIT_coerce_scale_type\n",itype);
00224       EXRETURN ;
00225       case MRI_complex:  cin = (complex *) ivol ; break ;
00226       case MRI_short  :  sin = (short   *) ivol ; break ;
00227       case MRI_float  :  fin = (float   *) ivol ; break ;
00228       case MRI_byte   :  bin = (byte    *) ivol ; break ;
00229       case MRI_double :  din = (double  *) ivol ; break ;
00230    }
00231    switch( otype ){
00232       default:
00233         fprintf(stderr,"** Unknown otype=%d in EDIT_coerce_scale_type\n",otype);
00234       EXRETURN ;
00235       case MRI_complex:  cout = (complex *) ovol ; break ;
00236       case MRI_short  :  sout = (short   *) ovol ; break ;
00237       case MRI_float  :  fout = (float   *) ovol ; break ;
00238       case MRI_byte   :  bout = (byte    *) ovol ; break ;
00239       case MRI_double :  dout = (double  *) ovol ; break ;
00240    }
00241 
00242    switch( otype ){
00243 
00244       /*** outputs are shorts ***/
00245 
00246       case MRI_short:
00247          switch( itype ){
00248             case MRI_short:   /* inputs are shorts */
00249                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*sin[ii]) ;
00250                EXRETURN ;
00251             case MRI_float:   /* inputs are floats */
00252                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*fin[ii]) ;
00253                EXRETURN ;
00254             case MRI_double:   /* inputs are double */
00255                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*din[ii]) ;
00256                EXRETURN ;
00257             case MRI_byte:    /* inputs are bytes */
00258                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*bin[ii]) ;
00259                EXRETURN ;
00260             case MRI_complex:    /* inputs are complex */
00261                for( ii=0 ; ii < nxyz ; ii++ ) sout[ii] = ROUND(fac*CABS(cin[ii])) ;
00262                EXRETURN ;
00263          }
00264          EXRETURN ;
00265 
00266       /*** outputs are floats ***/
00267 
00268       case MRI_float:
00269          switch( itype ){
00270             case MRI_short:   /* inputs are shorts */
00271                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*sin[ii] ;
00272                EXRETURN ;
00273             case MRI_float:   /* inputs are floats */
00274                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*fin[ii] ;
00275                EXRETURN ;
00276             case MRI_double:   /* inputs are doubles */
00277                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*din[ii] ;
00278                EXRETURN ;
00279             case MRI_byte:    /* inputs are bytes */
00280                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*bin[ii] ;
00281                EXRETURN ;
00282             case MRI_complex:    /* inputs are complex */
00283                for( ii=0 ; ii < nxyz ; ii++ ) fout[ii] = fac*CABS(cin[ii]) ;
00284                EXRETURN ;
00285          }
00286          EXRETURN ;
00287 
00288       /*** outputs are doubles ***/
00289 
00290       case MRI_double:
00291          switch( itype ){
00292             case MRI_short:   /* inputs are shorts */
00293                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*sin[ii] ;
00294                EXRETURN ;
00295             case MRI_float:   /* inputs are floats */
00296                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*fin[ii] ;
00297                EXRETURN ;
00298             case MRI_double:   /* inputs are doubles */
00299                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*din[ii] ;
00300                EXRETURN ;
00301             case MRI_byte:    /* inputs are bytes */
00302                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*bin[ii] ;
00303                EXRETURN ;
00304             case MRI_complex:    /* inputs are complex */
00305                for( ii=0 ; ii < nxyz ; ii++ ) dout[ii] = fac*CABS(cin[ii]) ;
00306                EXRETURN ;
00307          }
00308          EXRETURN ;
00309 
00310       /*** outputs are bytes ***/
00311 
00312       case MRI_byte:
00313          switch( itype ){
00314             case MRI_short:   /* inputs are shorts */
00315                for( ii=0 ; ii < nxyz ; ii++ ){
00316                   val = fac*sin[ii] ; bout[ii] = FLOAT_TO_BYTE(val) ;
00317                }
00318                EXRETURN ;
00319             case MRI_float:   /* inputs are floats */
00320                for( ii=0 ; ii < nxyz ; ii++ ){
00321                   val = fac*fin[ii] ; bout[ii] = FLOAT_TO_BYTE(val) ;
00322                }
00323                EXRETURN ;
00324             case MRI_double:   /* inputs are doubles */
00325                for( ii=0 ; ii < nxyz ; ii++ ){
00326                   val = fac*din[ii] ; bout[ii] = FLOAT_TO_BYTE(val) ;
00327                }
00328                EXRETURN ;
00329             case MRI_byte:    /* inputs are bytes */
00330                for( ii=0 ; ii < nxyz ; ii++ ){
00331                   val = fac*bin[ii] ; bout[ii] = FLOAT_TO_BYTE(val) ;
00332                }
00333                EXRETURN ;
00334             case MRI_complex:{    /* inputs are complex */
00335                for( ii=0 ; ii < nxyz ; ii++ ){
00336                   val = fac*CABS(cin[ii]) ; bout[ii] = FLOAT_TO_BYTE(val) ;
00337                }
00338             }
00339             EXRETURN ;
00340          }
00341          EXRETURN ;
00342 
00343       /*** outputs are complex ***/
00344 
00345       case MRI_complex:
00346          switch( itype ){
00347             case MRI_short:   /* inputs are shorts */
00348                for( ii=0 ; ii < nxyz ; ii++ )
00349                   cout[ii].r = fac*sin[ii] , cout[ii].i = 0.0 ;
00350                EXRETURN ;
00351             case MRI_float:   /* inputs are floats */
00352                for( ii=0 ; ii < nxyz ; ii++ )
00353                   cout[ii].r = fac*fin[ii] , cout[ii].i = 0.0 ;
00354                EXRETURN ;
00355             case MRI_double:   /* inputs are doubles */
00356                for( ii=0 ; ii < nxyz ; ii++ )
00357                   cout[ii].r = fac*din[ii] , cout[ii].i = 0.0 ;
00358                EXRETURN ;
00359             case MRI_byte:    /* inputs are bytes */
00360                for( ii=0 ; ii < nxyz ; ii++ )
00361                   cout[ii].r = fac*bin[ii] , cout[ii].i = 0.0 ;
00362                EXRETURN ;
00363             case MRI_complex:    /* inputs are complex */
00364                for( ii=0 ; ii < nxyz ; ii++ )
00365                   cout[ii].r = fac*cin[ii].r , cout[ii].i = fac*cin[ii].i ;
00366                EXRETURN ;
00367          }
00368          EXRETURN ;
00369    }
00370    EXRETURN ;
00371 }
00372 
00373 /*------------------------------------------------------------------------
00374   Convert one volume to another type, autoscaling:
00375      nxy   = # voxels
00376      itype = input datum type
00377      ivol  = pointer to input volume
00378      otype = output datum type
00379      ovol  = pointer to output volume (again, must be pre-malloc-ed)
00380   Return value is the scaling factor used (0.0 --> no scaling).
00381 --------------------------------------------------------------------------*/
00382 
00383 float EDIT_coerce_autoscale( int nxyz ,
00384                              int itype,void *ivol , int otype,void *ovol )
00385 {
00386    float fac=0.0 , top ;
00387 
00388 ENTRY("EDIT_coerce_autoscale") ;
00389 
00390    if( MRI_IS_INT_TYPE(otype) ){
00391       top = MCW_vol_amax( nxyz,1,1 , itype,ivol ) ;
00392       fac = (top > MRI_TYPE_maxval[otype]) ? MRI_TYPE_maxval[otype]/top : 0.0 ;
00393    }
00394 
00395    EDIT_coerce_scale_type( nxyz , fac , itype,ivol , otype,ovol ) ;
00396    RETURN( fac );
00397 }
00398 
00399 /*-----------------------------------------------------------------------*/
00400 
00401 void EDIT_clip_float( float top , int nxyz , float * vol )
00402 {
00403    int ii ;
00404    float bot ;
00405 
00406 ENTRY("EDIT_clip_float") ;
00407 
00408    if( top <= 0.0 || nxyz <= 0 || vol == NULL ) EXRETURN ;
00409 
00410    bot = -top ;
00411 
00412    for( ii=0 ; ii < nxyz ; ii++ )
00413            if( vol[ii] > top ) vol[ii] = top ;
00414       else if( vol[ii] < bot ) vol[ii] = bot ;
00415 
00416    EXRETURN ;
00417 }