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 /*** 7D SAFE ***/
00010 
00011 MRI_IMAGE *mri_to_short( double scl , MRI_IMAGE *oldim )
00012 {
00013    MRI_IMAGE *newim ;
00014    register int ii , npix ;
00015    register double scale , val ;
00016 
00017 ENTRY("mri_to_short") ;
00018 
00019    if( oldim == NULL ) RETURN( NULL );  /* 09 Feb 1999 */
00020 
00021    newim = mri_new_conforming( oldim , MRI_short ) ;
00022    npix  = oldim->nvox ;
00023 
00024    if( scl == 0.0 ){
00025       switch( oldim->kind ){
00026          case MRI_int:
00027          case MRI_float:
00028          case MRI_double:
00029          case MRI_complex:
00030             scale = mri_maxabs( oldim ) ;
00031             if( scale != 0.0 ) scale = 10000.0 / scale ;
00032 #ifdef MRI_DEBUG
00033    fprintf( stderr , "mri_to_short: scale factor = %e\n" , scale ) ;
00034 #endif
00035             break ;
00036 
00037          default:
00038             scale = 1.0 ;
00039             break ;
00040       }
00041    } else {
00042       scale = scl ;
00043    }
00044 
00045    switch( oldim->kind ){
00046 
00047       case MRI_rgb:{
00048          byte *rgb = oldim->im.rgb_data ;
00049          float rfac=0.299*scale , gfac=0.587*scale , bfac=0.114*scale ;
00050 
00051          for( ii=0 ; ii < npix ; ii++ )
00052             newim->im.short_data[ii] = (short)(  rfac * rgb[3*ii]
00053                                                + gfac * rgb[3*ii+1]
00054                                                + bfac * rgb[3*ii+2] ) ;
00055       }
00056       break ;
00057 
00058       case MRI_byte:
00059          if( scale != 1.0 )
00060             for( ii=0 ; ii < npix ; ii++ ){
00061                val = scale * oldim->im.byte_data[ii] ;
00062                newim->im.short_data[ii] = SHORTIZE(val) ;
00063             }
00064          else
00065             for( ii=0 ; ii < npix ; ii++ )
00066                newim->im.short_data[ii] = (short) oldim->im.byte_data[ii] ;
00067          break ;
00068 
00069       case MRI_short:
00070 #ifndef DONT_USE_MEMCPY       /* this is a double negative! */
00071          if( scale != 1.0 )
00072 #endif
00073             for( ii=0 ; ii < npix ; ii++ ){
00074                val = scale * oldim->im.short_data[ii] ;
00075                newim->im.short_data[ii] = SHORTIZE(val) ;
00076             }
00077 #ifndef DONT_USE_MEMCPY
00078          else
00079             (void) memcpy( newim->im.short_data ,
00080                            oldim->im.short_data , sizeof(short)*npix ) ;
00081 #endif
00082          break ;
00083 
00084       case MRI_int:
00085          if( scale != 1.0 )
00086             for( ii=0 ; ii < npix ; ii++ ){
00087                val = scale * oldim->im.int_data[ii] ;
00088                newim->im.short_data[ii] = SHORTIZE(val) ;
00089             }
00090          else
00091             for( ii=0 ; ii < npix ; ii++ )
00092                newim->im.short_data[ii] = SHORTIZE(oldim->im.int_data[ii]) ;
00093          break ;
00094 
00095       case MRI_float:
00096          if( scale != 1.0 )
00097             for( ii=0 ; ii < npix ; ii++ ){
00098                val = scale * oldim->im.float_data[ii] ;
00099                newim->im.short_data[ii] = SHORTIZE(val) ;
00100             }
00101          else
00102             for( ii=0 ; ii < npix ; ii++ )
00103                newim->im.short_data[ii] = SHORTIZE(oldim->im.float_data[ii]) ;
00104          break ;
00105 
00106       case MRI_double:
00107          for( ii=0 ; ii < npix ; ii++ )
00108             newim->im.short_data[ii] = scale * oldim->im.double_data[ii] ;
00109          break ;
00110 
00111       case MRI_complex:
00112         for( ii=0 ; ii < npix ; ii++ )
00113            newim->im.short_data[ii] = scale * CABS(oldim->im.complex_data[ii]) ;
00114         break ;
00115 
00116       default:
00117          fprintf( stderr , "mri_to_short:  unrecognized image kind\n" ) ;
00118          MRI_FATAL_ERROR ;
00119    }
00120 
00121    MRI_COPY_AUX(newim,oldim) ;
00122    RETURN( newim );
00123 }
00124 
00125 /*========================================================================*/
00126 
00127 MRI_IMAGE *mri_to_short_scl( double scl , double lev , MRI_IMAGE *oldim )
00128 {
00129    MRI_IMAGE * im ;
00130    im =  mri_to_short_sclip( scl , lev , 0,0 , oldim ) ;
00131    return im ;
00132 }
00133 
00134 
00135 /* scale, lev->0, and clip */
00136 
00137 MRI_IMAGE *mri_to_short_sclip( double scl , double lev ,
00138                                int bot , int top , MRI_IMAGE *oldim )
00139 {
00140    MRI_IMAGE *newim ;
00141    register int ii , npix ;
00142    double   imin,imax ;
00143    register double dscale , dbbot ;
00144    register float  scale  , flbot , val ;
00145    register short * ar ;
00146 
00147 ENTRY("mri_to_short_sclip") ;
00148 
00149    if( oldim == NULL ) RETURN( NULL );  /* 09 Feb 1999 */
00150 
00151    newim = mri_new_conforming( oldim , MRI_short ) ;
00152    npix  = oldim->nvox ;
00153 
00154    if( scl == 0 ){  /* compute scaling to make [min..max] -> [0..lev] */
00155 
00156       imin = (oldim->kind==MRI_complex || oldim->kind==MRI_rgb) ? (0) : mri_min(oldim) ;
00157       imax = mri_max( oldim ) ;
00158       imax = (imax <= imin) ? imin+1 : imax ;
00159 
00160       scale = dscale = (lev+0.99) / (imax-imin)  ;
00161       flbot = dbbot  = imin ;
00162 
00163    } else {          /* user controlled scaling, with lev -> 0 */
00164       scale = dscale = scl ;
00165       flbot = dbbot  = lev ;
00166    }
00167 
00168    ar = mri_data_pointer( newim ) ;  /* fast access to data */
00169 
00170    switch( oldim->kind ){
00171 
00172       case MRI_rgb:{
00173          register byte * rgb = mri_data_pointer(oldim) ;
00174          float rfac=0.299*scale , gfac=0.587*scale , bfac=0.114*scale ;
00175          for( ii=0 ; ii < npix ; ii++ )
00176             ar[ii] = (short) (  rfac * rgb[3*ii]
00177                               + gfac * rgb[3*ii+1]
00178                               + bfac * rgb[3*ii+2] ) ;
00179       }
00180       break ;
00181 
00182       case MRI_byte:{
00183          register byte * oar = mri_data_pointer(oldim) ;
00184          for( ii=0 ; ii < npix ; ii++ ){
00185             val = scale * (oar[ii]-flbot) ;
00186             ar[ii] = BYTEIZE(val) ;
00187          }
00188          break ;
00189       }
00190 
00191       case MRI_short:{
00192          register short * oar = mri_data_pointer(oldim) ;
00193          for( ii=0 ; ii < npix ; ii++ ){
00194             val = scale * (oar[ii]-flbot) ;
00195             ar[ii] = SHORTIZE(val) ;
00196          }
00197          break ;
00198       }
00199 
00200       case MRI_int:{
00201          register int * oar = mri_data_pointer(oldim) ;
00202          for( ii=0 ; ii < npix ; ii++ )
00203             ar[ii] = scale * (oar[ii]-flbot) ;
00204          break ;
00205       }
00206 
00207       case MRI_float:{
00208          register float * oar = mri_data_pointer(oldim) ;
00209          for( ii=0 ; ii < npix ; ii++ )
00210             ar[ii] = scale * (oar[ii]-flbot) ;
00211          break ;
00212       }
00213 
00214       case MRI_double:{
00215          register double * oar = mri_data_pointer(oldim) ;
00216          for( ii=0 ; ii < npix ; ii++ )
00217             ar[ii] = dscale * (oar[ii]-dbbot) ;
00218          break ;
00219       }
00220 
00221       case MRI_complex:{
00222          register complex * oar = mri_data_pointer(oldim) ;
00223          for( ii=0 ; ii < npix ; ii++ )
00224             ar[ii] = scale * CABS(oar[ii]) ;
00225          break ;
00226       }
00227 
00228       default:
00229          fprintf( stderr , "mri_to_short_scl:  unrecognized image kind\n" ) ;
00230          MRI_FATAL_ERROR ;
00231    }
00232 
00233    /* clip, if desired */
00234 
00235    if( bot < top ){
00236       register short bb = bot , tt = top ;
00237       for( ii=0 ; ii < npix ; ii++ ){
00238               if( ar[ii] < bb ) ar[ii] = bb ;
00239          else if( ar[ii] > tt ) ar[ii] = tt ;
00240       }
00241    }
00242 
00243    MRI_COPY_AUX(newim,oldim) ;
00244    RETURN( newim );
00245 }