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 [some of it] ***/
00010 
00011 MRI_IMAGE *mri_to_rgb( MRI_IMAGE *oldim )  /* 11 Feb 1999 */
00012 {
00013    MRI_IMAGE *newim ;
00014    register int ii , npix ;
00015    register byte * rgb ;
00016 
00017 ENTRY("mri_to_rgb") ;
00018 
00019    if( oldim == NULL ) RETURN( NULL );
00020 
00021    newim = mri_new_conforming( oldim , MRI_rgb ) ; rgb = MRI_RGB_PTR(newim) ;
00022    npix  = oldim->nvox ;
00023 
00024    switch( oldim->kind ){
00025 
00026       case MRI_byte:
00027          for( ii=0 ; ii < npix ; ii++ )
00028             rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = oldim->im.byte_data[ii] ;
00029       break ;
00030 
00031       case MRI_float:
00032          for( ii=0 ; ii < npix ; ii++ )
00033             rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = oldim->im.float_data[ii] ;
00034       break ;
00035 
00036       case MRI_short:
00037          for( ii=0 ; ii < npix ; ii++ )
00038             rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = oldim->im.short_data[ii] ;
00039       break ;
00040 
00041       case MRI_rgb:
00042          memcpy( rgb , MRI_RGB_PTR(oldim) , 3*npix ) ;
00043       break ;
00044 
00045       case MRI_rgba:
00046          for( ii=0 ; ii < npix ; ii++ ){
00047             rgb[3*ii]   = oldim->im.rgba_data[ii].r ;
00048             rgb[3*ii+1] = oldim->im.rgba_data[ii].g ;
00049             rgb[3*ii+2] = oldim->im.rgba_data[ii].b ;
00050          }
00051       break ;
00052 
00053       default:
00054          fprintf(stderr,"mri_to_rgb:  unrecognized image conversion %d\n",oldim->kind) ;
00055          RETURN( NULL );
00056    }
00057 
00058    MRI_COPY_AUX(newim,oldim) ;
00059    RETURN( newim );
00060 }
00061 
00062 /*---------------------------------------------------------------------------
00063    Inputs must be in same formats (# voxels and kinds)!
00064 -----------------------------------------------------------------------------*/
00065 
00066 MRI_IMAGE * mri_3to_rgb( MRI_IMAGE * rim , MRI_IMAGE * gim , MRI_IMAGE * bim )
00067 {
00068    MRI_IMAGE *newim ;
00069    register int ii , npix ;
00070    register byte * rgb ;
00071 
00072 ENTRY("mri_3to_rgb") ;
00073 
00074    if( rim == NULL || bim == NULL || gim == NULL ) RETURN( NULL );
00075 
00076    newim = mri_new_conforming( rim , MRI_rgb ) ; rgb = MRI_BYTE_PTR(newim) ;
00077    npix  = rim->nvox ;
00078 
00079    switch( rim->kind ){
00080 
00081       case MRI_byte:{
00082          byte * rr=MRI_BYTE_PTR(rim), * gg=MRI_BYTE_PTR(gim), * bb=MRI_BYTE_PTR(bim) ;
00083          for( ii=0 ; ii < npix ; ii++ ){
00084             rgb[3*ii  ] = rr[ii] ;
00085             rgb[3*ii+1] = gg[ii] ;
00086             rgb[3*ii+2] = bb[ii] ;
00087          }
00088       }
00089       break ;
00090 
00091       case MRI_float:{
00092          float * rr=MRI_FLOAT_PTR(rim), * gg=MRI_FLOAT_PTR(gim), * bb=MRI_FLOAT_PTR(bim) ;
00093          for( ii=0 ; ii < npix ; ii++ ){
00094             rgb[3*ii  ] = rr[ii] ;
00095             rgb[3*ii+1] = gg[ii] ;
00096             rgb[3*ii+2] = bb[ii] ;
00097          }
00098       }
00099       break ;
00100 
00101       default:
00102          fprintf(stderr,"mri_3to_rgb:  unrecognized image conversion %d\n",rim->kind) ;
00103          MRI_FATAL_ERROR ;
00104    }
00105 
00106    MRI_COPY_AUX(newim,rim) ;
00107    RETURN( newim );
00108 }
00109 
00110 /*-------------------------------------------------------------------------------*/
00111 
00112 MRI_IMARR * mri_rgb_to_3float( MRI_IMAGE * oldim )
00113 {
00114    MRI_IMARR * imar ;
00115    MRI_IMAGE * rim , * gim , * bim ;
00116    float     * rr  , * gg  , * bb  ;
00117    byte      * rgb ;
00118    int ii , npix ;
00119 
00120 ENTRY("mri_rgb_to_3float") ;
00121 
00122    if( oldim == NULL || oldim->kind != MRI_rgb ) RETURN( NULL );
00123 
00124    rim = mri_new_conforming( oldim , MRI_float ) ; rr = MRI_FLOAT_PTR(rim) ;
00125    gim = mri_new_conforming( oldim , MRI_float ) ; gg = MRI_FLOAT_PTR(gim) ;
00126    bim = mri_new_conforming( oldim , MRI_float ) ; bb = MRI_FLOAT_PTR(bim) ;
00127                                                    rgb= MRI_BYTE_PTR(oldim) ;
00128    npix = oldim->nvox ;
00129 
00130    for( ii=0 ; ii < npix ; ii++ ){
00131       rr[ii] = rgb[3*ii  ] ;
00132       gg[ii] = rgb[3*ii+1] ;
00133       bb[ii] = rgb[3*ii+2] ;
00134    }
00135 
00136    INIT_IMARR(imar) ;
00137    ADDTO_IMARR(imar,rim) ; ADDTO_IMARR(imar,gim) ; ADDTO_IMARR(imar,bim) ;
00138 
00139    RETURN( imar );
00140 }
00141 
00142 /*-------------------------------------------------------------------------------*/
00143 
00144 MRI_IMARR * mri_rgb_to_3byte( MRI_IMAGE * oldim )  /* 15 Apr 1999 */
00145 {
00146    MRI_IMARR * imar ;
00147    MRI_IMAGE * rim , * gim , * bim ;
00148    byte      * rr  , * gg  , * bb  , * rgb ;
00149    int ii , npix ;
00150 
00151 ENTRY("mri_rgb_to_3byte") ;
00152    if( oldim == NULL || oldim->kind != MRI_rgb ) RETURN( NULL );
00153 
00154    rim = mri_new_conforming( oldim , MRI_byte ) ; rr = MRI_BYTE_PTR(rim) ;
00155    gim = mri_new_conforming( oldim , MRI_byte ) ; gg = MRI_BYTE_PTR(gim) ;
00156    bim = mri_new_conforming( oldim , MRI_byte ) ; bb = MRI_BYTE_PTR(bim) ;
00157                                                   rgb= MRI_BYTE_PTR(oldim) ;
00158    npix = oldim->nvox ;
00159 
00160    for( ii=0 ; ii < npix ; ii++ ){
00161       rr[ii] = rgb[3*ii  ] ;
00162       gg[ii] = rgb[3*ii+1] ;
00163       bb[ii] = rgb[3*ii+2] ;
00164    }
00165 
00166    INIT_IMARR(imar) ;
00167    ADDTO_IMARR(imar,rim) ; ADDTO_IMARR(imar,gim) ; ADDTO_IMARR(imar,bim) ;
00168 
00169    RETURN( imar );
00170 }
00171 
00172 /*-----------------------------------------------------------------------------*/
00173 
00174 MRI_IMAGE * mri_sharpen_rgb( float phi , MRI_IMAGE * im )
00175 {
00176    MRI_IMAGE * flim , * shim , * newim ;
00177    byte  * iar , * nar ;
00178    float * sar , * far ;
00179    int ii , nvox , rr,gg,bb ;
00180    float fac ;
00181 
00182 ENTRY("mri_sharpen_rgb") ;
00183 
00184    if( im == NULL ) RETURN( NULL );
00185 
00186    if( im->kind != MRI_rgb ) RETURN( mri_sharpen(phi,0,im) );
00187 
00188    flim  = mri_to_float( im ) ;                  /* intensity of input */
00189    shim  = mri_sharpen( phi , 0 , flim ) ;       /* sharpen intensity */
00190    newim = mri_new_conforming( im , MRI_rgb ) ;  /* will be output    */
00191 
00192    nar = MRI_BYTE_PTR(newim) ; iar = MRI_BYTE_PTR(im) ;
00193    far = MRI_FLOAT_PTR(flim) ; sar = MRI_FLOAT_PTR(shim) ;
00194 
00195    nvox = newim->nvox ;
00196    for( ii=0 ; ii < nvox ; ii++ ){
00197       if( far[ii] <= 0.0 || sar[ii] <= 0.0 ){
00198          nar[3*ii] = nar[3*ii+1] = nar[3*ii+2] = 0 ;
00199       } else {
00200          fac = sar[ii] / far[ii] ; /* will be positive */
00201          rr  = fac * iar[3*ii]   ;
00202          gg  = fac * iar[3*ii+1] ;
00203          bb  = fac * iar[3*ii+2] ;
00204          nar[3*ii  ] = (rr > 255) ? 255 : rr ;
00205          nar[3*ii+1] = (gg > 255) ? 255 : gg ;
00206          nar[3*ii+2] = (bb > 255) ? 255 : bb ;
00207       }
00208    }
00209 
00210    mri_free(flim) ; mri_free(shim) ;
00211 
00212    MRI_COPY_AUX(newim,im) ;
00213    RETURN( newim );
00214 }
00215 
00216 /*-----------------------------------------------------------------------------*/
00217 
00218 MRI_IMAGE * mri_flatten_rgb( MRI_IMAGE * im )
00219 {
00220    MRI_IMAGE * flim , * shim , * newim ;
00221    byte  * iar , * nar ;
00222    float * sar , * far ;
00223    int ii , nvox , rr,gg,bb ;
00224    float fac ;
00225 
00226 ENTRY("mri_flatten_rgb") ;
00227 
00228    if( im == NULL ) RETURN( NULL );
00229 
00230    if( im->kind != MRI_rgb ) RETURN( mri_flatten(im) );
00231 
00232    flim  = mri_to_float( im ) ;                  /* intensity of input */
00233    shim  = mri_flatten( flim ) ;                 /* flatten intensity  */
00234    newim = mri_new_conforming( im , MRI_rgb ) ;  /* will be output     */
00235 
00236    nar = MRI_BYTE_PTR(newim) ; iar = MRI_BYTE_PTR(im) ;
00237    far = MRI_FLOAT_PTR(flim) ; sar = MRI_FLOAT_PTR(shim) ;
00238    nvox = newim->nvox ;
00239 
00240    for( ii=0 ; ii < nvox ; ii++ ){
00241       if( far[ii] <= 0.0 || sar[ii] <= 0.0 ){
00242          nar[3*ii] = nar[3*ii+1] = nar[3*ii+2] = 0 ;
00243       } else {
00244          fac = 255.9 * sar[ii] / far[ii] ; /* will be positive */
00245          rr  = fac * iar[3*ii]   ;
00246          gg  = fac * iar[3*ii+1] ;
00247          bb  = fac * iar[3*ii+2] ;
00248          nar[3*ii  ] = (rr > 255) ? 255 : rr ;
00249          nar[3*ii+1] = (gg > 255) ? 255 : gg ;
00250          nar[3*ii+2] = (bb > 255) ? 255 : bb ;
00251       }
00252    }
00253 
00254    mri_free(flim) ; mri_free(shim) ;
00255 
00256    MRI_COPY_AUX(newim,im) ;
00257    RETURN( newim );
00258 }
00259 
00260 /*-----------------------------------------------------------------------------*/
00261 
00262 void mri_invert_inplace( MRI_IMAGE *im )
00263 {
00264    register byte *bar ;
00265    register int ii , nbar ;
00266 
00267 ENTRY("mri_invert_inplace") ;
00268 
00269    if( im == NULL ) EXRETURN ;
00270    switch( im->kind ){
00271      default: EXRETURN ;
00272      case MRI_byte:  nbar =   im->nvox ; bar = MRI_BYTE_PTR(im) ; break ;
00273      case MRI_rgb:   nbar = 3*im->nvox ; bar = MRI_RGB_PTR(im)  ; break ;
00274    }
00275    for( ii=0 ; ii < nbar ; ii++ ) bar[ii] = 255 - bar[ii] ;
00276    EXRETURN ;
00277 }