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_byte( MRI_IMAGE *oldim )
00012 {
00013    MRI_IMAGE *newim ;
00014    register int ii , npix ;
00015    double   imin,imax ;
00016    register double scale ;
00017    short  shbot ;
00018    int    inbot ;
00019    float  flbot ;
00020    double dbbot ;
00021    byte *ar ;
00022 
00023 ENTRY("mri_to_byte") ;
00024 
00025    if( oldim == NULL ) RETURN( NULL );  /* 09 Feb 1999 */
00026 
00027    newim = mri_new_conforming( oldim , MRI_byte ) ;
00028    npix  = oldim->nvox ;
00029 
00030    switch( oldim->kind ){
00031       case MRI_short:
00032       case MRI_int:
00033       case MRI_float:
00034       case MRI_double:
00035          imin  = mri_min( oldim ) ;
00036          imax  = mri_max( oldim ) ;
00037          imax  = (imax <= imin) ? imin+1 : imax ;
00038          scale = 255.9 / (imax-imin)  ;
00039          switch( oldim->kind ){
00040             case MRI_short:    shbot = imin ; break ;
00041             case MRI_int:      inbot = imin ; break ;
00042             case MRI_float:    flbot = imin ; break ;
00043             case MRI_double:   dbbot = imin ; break ;
00044          }
00045          break ;
00046 
00047       case MRI_complex:
00048          scale = 255.9 / mri_max( oldim ) ;
00049          break ;
00050    }
00051 
00052    ar = MRI_BYTE_PTR( newim ) ;  /* fast access to data */
00053 
00054    switch( oldim->kind ){
00055 
00056       case MRI_byte:
00057 #ifdef DONT_USE_MEMCPY
00058          for( ii=0 ; ii < npix ; ii++ )
00059             ar[ii] = oldim->im.byte_data[ii] ;
00060 #else
00061          (void) memcpy( ar , oldim->im.byte_data , sizeof(byte)*npix ) ;
00062 #endif
00063          break ;
00064 
00065       case MRI_rgb:{                           /* 13 Nov 2002 */
00066          byte *rgb = oldim->im.rgb_data ;
00067          float rfac=0.299*scale , gfac=0.587*scale , bfac=0.114*scale , val ;
00068          for( ii=0 ; ii < npix ; ii++ ){
00069            val = rfac * rgb[3*ii] + gfac * rgb[3*ii+1] + bfac * rgb[3*ii+2] ;
00070            ar[ii] = BYTEIZE(val) ;
00071          }
00072       }
00073       break ;
00074 
00075       case MRI_short:
00076          for( ii=0 ; ii < npix ; ii++ )
00077             ar[ii] = scale * (oldim->im.short_data[ii]-shbot) ;
00078          break ;
00079 
00080       case MRI_int:
00081          for( ii=0 ; ii < npix ; ii++ )
00082             ar[ii] = scale * (oldim->im.int_data[ii]-inbot) ;
00083          break ;
00084 
00085       case MRI_float:
00086          for( ii=0 ; ii < npix ; ii++ )
00087             ar[ii] = scale * (oldim->im.float_data[ii]-flbot) ;
00088          break ;
00089 
00090       case MRI_double:
00091          for( ii=0 ; ii < npix ; ii++ )
00092             ar[ii] = scale * (oldim->im.double_data[ii]-dbbot) ;
00093          break ;
00094 
00095       case MRI_complex:
00096          for( ii=0 ; ii < npix ; ii++ )
00097             ar[ii] = scale * CABS(oldim->im.complex_data[ii]) ;
00098          break ;
00099 
00100       default:
00101          fprintf( stderr , "mri_to_byte:  unrecognized image kind\n" ) ;
00102          MRI_FATAL_ERROR ;
00103    }
00104 
00105    MRI_COPY_AUX(newim,oldim) ;
00106    RETURN( newim );
00107 }
00108 
00109 /*----------------------------------------------------------------------------*/
00110 
00111 MRI_IMAGE *mri_to_byte_scl( double scl , double lev , MRI_IMAGE *oldim )
00112 {
00113    MRI_IMAGE *newim ;
00114    register int ii , npix ;
00115    double   imin,imax ;
00116    register double dscale , dbbot ;
00117    register float  scale  , flbot , val ;
00118    register byte *ar ;
00119 
00120 ENTRY("mri_to_byte_scl") ;
00121 
00122    if( oldim == NULL ) RETURN( NULL );  /* 09 Feb 1999 */
00123 
00124    newim = mri_new_conforming( oldim , MRI_byte ) ;
00125    npix  = oldim->nvox ;
00126 
00127    if( scl == 0 ){  /* compute scaling to make (min..max) -> (0..lev) */
00128 
00129       imin = (oldim->kind == MRI_complex) ? (0) : mri_min( oldim ) ;
00130       imax = mri_max( oldim ) ;
00131       imax = (imax <= imin) ? imin+1 : imax ;
00132 
00133       scale = dscale = (lev+0.99) / (imax-imin)  ;
00134       flbot = dbbot  = imin ;
00135 
00136    } else {          /* user controlled scaling, with lev -> 0 */
00137       scale = dscale = scl ;
00138       flbot = dbbot  = lev ;
00139    }
00140 
00141    ar = MRI_BYTE_PTR( newim ) ;  /* fast access to data */
00142 
00143    switch( oldim->kind ){
00144 
00145       case MRI_byte:
00146          for( ii=0 ; ii < npix ; ii++ ){
00147             val = scale * (oldim->im.byte_data[ii]-flbot) ;
00148             ar[ii] = BYTEIZE(val) ;
00149          }
00150          break ;
00151 
00152       case MRI_short:
00153          for( ii=0 ; ii < npix ; ii++ ){
00154             val = scale * (oldim->im.short_data[ii]-flbot) ;
00155             ar[ii] = BYTEIZE(val) ;
00156          }
00157          break ;
00158 
00159       case MRI_int:
00160          for( ii=0 ; ii < npix ; ii++ ){
00161             val = scale * (oldim->im.int_data[ii]-flbot) ;
00162             ar[ii] = BYTEIZE(val) ;
00163          }
00164          break ;
00165 
00166       case MRI_float:
00167          for( ii=0 ; ii < npix ; ii++ ){
00168             val = scale * (oldim->im.float_data[ii]-flbot) ;
00169             ar[ii] = BYTEIZE(val) ;
00170          }
00171          break ;
00172 
00173       case MRI_double:
00174          for( ii=0 ; ii < npix ; ii++ )
00175             ar[ii] = dscale * (oldim->im.double_data[ii]-dbbot) ;
00176          break ;
00177 
00178       case MRI_complex:
00179          for( ii=0 ; ii < npix ; ii++ )
00180             ar[ii] = scale * CABS(oldim->im.complex_data[ii]) ;
00181          break ;
00182 
00183       default:
00184          fprintf( stderr , "mri_to_byte_scl:  unrecognized image kind\n" ) ;
00185          MRI_FATAL_ERROR ;
00186    }
00187 
00188    MRI_COPY_AUX(newim,oldim) ;
00189    RETURN( newim );
00190 }