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 #include <math.h>
00009 
00010 /*** 7D SAFE ***/
00011 
00012 double mri_max( MRI_IMAGE *im )
00013 {
00014    register int ii , npix ;
00015    byte   byte_max   = 0 ;
00016    short  short_max  = -32767 ;       /* 23 Oct 1998: changed from 0 */
00017    int    int_max    = -2147483647 ;  /* ditto */
00018    float  float_max  = -1.e+38 ;      /* changed from -9999999.0 */
00019    double double_max = -1.e+38 ;      /* ditto */
00020 
00021    npix = im->nvox ;
00022 
00023    switch( im->kind ){
00024 
00025       case MRI_byte:
00026          for( ii=0 ; ii < npix ; ii++ )
00027             byte_max = MAX( byte_max , im->im.byte_data[ii] ) ;
00028          return (double) byte_max ;
00029 
00030       case MRI_short:
00031          for( ii=0 ; ii < npix ; ii++ )
00032             short_max = MAX( short_max , im->im.short_data[ii] ) ;
00033          return (double) short_max ;
00034 
00035       case MRI_int:
00036          for( ii=0 ; ii < npix ; ii++ )
00037             int_max = MAX( int_max , im->im.int_data[ii] ) ;
00038          return (double) int_max ;
00039 
00040       case MRI_float:
00041          for( ii=0 ; ii < npix ; ii++ )
00042             float_max = MAX( float_max , im->im.float_data[ii] ) ;
00043          return (double) float_max ;
00044 
00045       case MRI_double:
00046          for( ii=0 ; ii < npix ; ii++ )
00047             double_max = MAX( double_max , im->im.double_data[ii] ) ;
00048          return double_max ;
00049 
00050       case MRI_complex:
00051          for( ii=0 ; ii < npix ; ii++ )
00052             float_max = MAX( float_max , CSQR(im->im.complex_data[ii]) ) ;
00053          return sqrt(float_max) ;
00054 
00055       case MRI_rgb:{
00056          byte *rgb = im->im.rgb_data ;
00057          double val , top=0.0 ;
00058          for( ii=0 ; ii < npix ; ii++ ){  /* scale to brightness */
00059             val =  0.299 * rgb[3*ii]      /* between 0 and 255     */
00060                  + 0.587 * rgb[3*ii+1]
00061                  + 0.114 * rgb[3*ii+2] ;
00062             if( val > top ) top = val ;
00063          }
00064          return top ;
00065       }
00066 
00067       default:
00068          fprintf( stderr , "mri_max:  unknown image kind\n" ) ;
00069    }
00070    return 0 ;
00071 }
00072 
00073 double mri_maxabs( MRI_IMAGE * im )
00074 {
00075    register int ii , npix ;
00076    byte   byte_max   = 0 ;
00077    int    int_max    = 0 ;
00078    double double_max = 0.0 ;
00079 
00080    npix = im->nvox ;
00081 
00082    switch( im->kind ){
00083 
00084       case MRI_byte:
00085          for( ii=0 ; ii < npix ; ii++ )
00086             byte_max = MAX( byte_max , im->im.byte_data[ii] ) ;
00087          return (double) byte_max ;
00088 
00089       case MRI_short:
00090          for( ii=0 ; ii < npix ; ii++ )
00091             int_max = MAX( int_max , abs(im->im.short_data[ii]) ) ;
00092          return (double) int_max ;
00093 
00094       case MRI_int:
00095          for( ii=0 ; ii < npix ; ii++ )
00096             int_max = MAX( int_max , abs(im->im.int_data[ii]) ) ;
00097          return (double) int_max ;
00098 
00099       case MRI_float:
00100          for( ii=0 ; ii < npix ; ii++ )
00101             double_max = MAX( double_max , fabs(im->im.float_data[ii]) ) ;
00102          return double_max ;
00103 
00104       case MRI_double:
00105          for( ii=0 ; ii < npix ; ii++ )
00106             double_max = MAX( double_max , fabs(im->im.double_data[ii]) ) ;
00107          return double_max ;
00108 
00109       case MRI_complex:
00110          for( ii=0 ; ii < npix ; ii++ )
00111             double_max = MAX( double_max , CSQR(im->im.complex_data[ii]) ) ;
00112          return sqrt(double_max) ;
00113 
00114       case MRI_rgb:
00115          return mri_max( im ) ;
00116 
00117       default:
00118          fprintf( stderr , "mri_max:  unknown image kind\n" ) ;
00119    }
00120    return 0 ;
00121 }
00122 
00123 double mri_min( MRI_IMAGE *im )
00124 {
00125    register int ii , npix ;
00126    byte   byte_min   = 255 ;
00127    short  short_min  = 32767 ;
00128    int    int_min    = 2147483647 ;
00129    float  float_min  = 1.e+38 ;
00130    double double_min = 1.e+38 ;
00131 
00132    npix = im->nvox ;
00133 
00134    switch( im->kind ){
00135 
00136       case MRI_byte:
00137          for( ii=0 ; ii < npix ; ii++ )
00138             byte_min = MIN( byte_min , im->im.byte_data[ii] ) ;
00139          return (double) byte_min ;
00140 
00141       case MRI_short:
00142          for( ii=0 ; ii < npix ; ii++ )
00143             short_min = MIN( short_min , im->im.short_data[ii] ) ;
00144          return (double) short_min ;
00145 
00146       case MRI_int:
00147          for( ii=0 ; ii < npix ; ii++ )
00148             int_min = MIN( int_min , im->im.int_data[ii] ) ;
00149          return (double) int_min ;
00150 
00151       case MRI_float:
00152          for( ii=0 ; ii < npix ; ii++ )
00153             float_min = MIN( float_min , im->im.float_data[ii] ) ;
00154          return (double) float_min ;
00155 
00156       case MRI_double:
00157          for( ii=0 ; ii < npix ; ii++ )
00158             double_min = MIN( double_min , im->im.double_data[ii] ) ;
00159          return double_min ;
00160 
00161       case MRI_complex:
00162          for( ii=0 ; ii < npix ; ii++ )
00163             float_min = MIN( float_min , CSQR(im->im.complex_data[ii]) ) ;
00164          return sqrt(float_min) ;
00165 
00166       case MRI_rgb:{
00167          byte *rgb = im->im.rgb_data ;
00168          double val , bot=255.9 ;
00169          for( ii=0 ; ii < npix ; ii++ ){  /* scale to brightness */
00170             val =  0.299 * rgb[3*ii]      /* between 0 and 255     */
00171                  + 0.587 * rgb[3*ii+1]
00172                  + 0.114 * rgb[3*ii+2] ;
00173             if( val < bot ) bot = val ;
00174          }
00175          return bot ;
00176       }
00177 
00178       default:
00179          fprintf( stderr , "mri_min:  unknown image kind\n" ) ;
00180    }
00181    return 0 ;
00182 }