Skip to content

AFNI/NIfTI Server

Sections
Personal tools
You are here: Home » AFNI » Documentation
 

Doxygen Source Code Documentation

Main Page   Alphabetical List   Data Structures   File List   Data Fields   Globals   Search  

mri_max.c File Reference

#include "mrilib.h"
#include <math.h>

Go to the source code of this file.


Functions

double mri_max (MRI_IMAGE *im)
double mri_maxabs (MRI_IMAGE *im)
double mri_min (MRI_IMAGE *im)

Function Documentation

double mri_max (  MRI_IMAGE *    im ) 
 

Definition at line 12 of file mri_max.c.

References MRI_DATA::byte_data, MRI_DATA::complex_data, CSQR, MRI_DATA::double_data, double_max, MRI_DATA::float_data, float_max, MRI_IMAGE::im, MRI_DATA::int_data, int_max, MRI_IMAGE::kind, MAX, MRI_IMAGE::nvox, MRI_DATA::rgb_data, MRI_DATA::short_data, short_max, and top.

Referenced by HISTO_main(), ISQ_process_mri(), ISQ_statify_one(), main(), mri_3dalign_one(), mri_3dalign_setup(), mri_align_crao(), mri_dup2D(), mri_edit_image(), mri_maxabs(), mri_quantile(), mri_rgb_transform_nD(), mri_sharpen(), mri_to_byte(), mri_to_byte_scl(), mri_to_mri(), mri_to_short_sclip(), mri_warp3D_align_setup(), mri_write_analyze(), T3D_read_images(), and write_images(). 

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 }

double mri_maxabs (  MRI_IMAGE *    im ) 
 

Definition at line 73 of file mri_max.c.

References abs, MRI_DATA::byte_data, MRI_DATA::complex_data, CSQR, MRI_DATA::double_data, double_max, MRI_DATA::float_data, MRI_IMAGE::im, MRI_DATA::int_data, int_max, MRI_IMAGE::kind, MAX, mri_max(), MRI_IMAGE::nvox, and MRI_DATA::short_data.

Referenced by AFNI_func_overlay(), main(), mri_brainormalize(), mri_to_mri(), mri_to_short(), PH_loadim(), PR_type_scale(), and THD_cliplevel(). 

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 }

double mri_min (  MRI_IMAGE *    im ) 
 

Definition at line 123 of file mri_max.c. 

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 }
 
Powered by Plone

This site conforms to the following standards: