/*****************************************************************************
   Major portions of this software are copyrighted by the Medical College
   of Wisconsin, 1994-2000, and are released under the Gnu General Public
   License, Version 2.  See the file README.Copyright for details.
******************************************************************************/

#include "mrilib.h"

/*** 7D SAFE [some of it] ***/

MRI_IMAGE *mri_to_rgb( MRI_IMAGE *oldim )  /* 11 Feb 1999 */
{
   MRI_IMAGE *newim ;
   register int ii , npix ;
   register byte * rgb ;

ENTRY("mri_to_rgb") ;

   if( oldim == NULL ) RETURN( NULL );

   newim = mri_new_conforming( oldim , MRI_rgb ) ; rgb = MRI_RGB_PTR(newim) ;
   npix  = oldim->nvox ;

   switch( oldim->kind ){

      case MRI_byte:{ byte *qar = MRI_BYTE_PTR(oldim) ;
        for( ii=0 ; ii < npix ; ii++ )
          rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = qar[ii] ;
      } break ;

      case MRI_float:{ float *qar = MRI_FLOAT_PTR(oldim) ;
        for( ii=0 ; ii < npix ; ii++ )
          rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = qar[ii] ;
      } break ;

      case MRI_short:{ short *qar = MRI_SHORT_PTR(oldim) ;
        for( ii=0 ; ii < npix ; ii++ )
          rgb[3*ii] = rgb[3*ii+1] = rgb[3*ii+2] = qar[ii] ;
      } break ;

      case MRI_rgb:
        memcpy( rgb , MRI_RGB_PTR(oldim) , 3*npix ) ;
      break ;

      case MRI_rgba:{ rgba *qar = MRI_RGBA_PTR(oldim) ;
        for( ii=0 ; ii < npix ; ii++ ){
          rgb[3*ii]   = qar[ii].r ;
          rgb[3*ii+1] = qar[ii].g ;
          rgb[3*ii+2] = qar[ii].b ;
        }
      } break ;

      default:
        ERROR_message("mri_to_rgb: unrecognized image conversion %d",oldim->kind) ;
        mri_free(newim) ; RETURN(NULL);
   }

   MRI_COPY_AUX(newim,oldim) ;
   RETURN( newim );
}

/*---------------------------------------------------------------------------
   Inputs must be in same formats (# voxels and kinds)!
-----------------------------------------------------------------------------*/

MRI_IMAGE * mri_3to_rgb( MRI_IMAGE *rim , MRI_IMAGE *gim , MRI_IMAGE *bim )
{
   MRI_IMAGE *newim ;
   register int ii , npix ;
   register byte * rgb ;

ENTRY("mri_3to_rgb") ;

   if( rim == NULL || bim == NULL || gim == NULL ) RETURN( NULL );

   newim = mri_new_conforming( rim , MRI_rgb ) ; rgb = MRI_BYTE_PTR(newim) ;
   npix  = rim->nvox ;

   switch( rim->kind ){

      case MRI_byte:{
        byte *rr=MRI_BYTE_PTR(rim), *gg=MRI_BYTE_PTR(gim), *bb=MRI_BYTE_PTR(bim) ;
        for( ii=0 ; ii < npix ; ii++ ){
          rgb[3*ii  ] = rr[ii] ;
          rgb[3*ii+1] = gg[ii] ;
          rgb[3*ii+2] = bb[ii] ;
        }
      }
      break ;

      case MRI_float:{
        float *rr=MRI_FLOAT_PTR(rim), *gg=MRI_FLOAT_PTR(gim), *bb=MRI_FLOAT_PTR(bim) ;
        for( ii=0 ; ii < npix ; ii++ ){
          rgb[3*ii  ] = rr[ii] ;
          rgb[3*ii+1] = gg[ii] ;
          rgb[3*ii+2] = bb[ii] ;
        }
      }
      break ;

      default:
        ERROR_message("mri_3to_rgb: unrecognized image conversion %d",rim->kind) ;
        mri_free(newim) ; RETURN(NULL) ;
   }

   MRI_COPY_AUX(newim,rim) ;
   RETURN( newim );
}

/*-------------------------------------------------------------------------------*/

MRI_IMARR * mri_rgb_to_3float( MRI_IMAGE *oldim )
{
   MRI_IMARR *imar ;
   MRI_IMAGE *rim , *gim , *bim ;
   float     *rr  , *gg  , *bb  ;
   byte      *rgb ;
   int ii , npix ;

ENTRY("mri_rgb_to_3float") ;

   if( oldim == NULL || oldim->kind != MRI_rgb ) RETURN( NULL );

   rim = mri_new_conforming( oldim , MRI_float ) ; rr = MRI_FLOAT_PTR(rim) ;
   gim = mri_new_conforming( oldim , MRI_float ) ; gg = MRI_FLOAT_PTR(gim) ;
   bim = mri_new_conforming( oldim , MRI_float ) ; bb = MRI_FLOAT_PTR(bim) ;
                                                   rgb= MRI_BYTE_PTR(oldim);
   npix = oldim->nvox ;

   for( ii=0 ; ii < npix ; ii++ ){
     rr[ii] = (float)rgb[3*ii  ] ;
     gg[ii] = (float)rgb[3*ii+1] ;
     bb[ii] = (float)rgb[3*ii+2] ;
   }

   INIT_IMARR(imar) ;
   ADDTO_IMARR(imar,rim) ; ADDTO_IMARR(imar,gim) ; ADDTO_IMARR(imar,bim) ;

   RETURN( imar );
}

/*-------------------------------------------------------------------------------*/

MRI_IMARR * mri_rgb_to_3byte( MRI_IMAGE *oldim )  /* 15 Apr 1999 */
{
   MRI_IMARR *imar ;
   MRI_IMAGE *rim , *gim , *bim ;
   byte      *rr  , *gg  , *bb  , *rgb ;
   int ii , npix ;

ENTRY("mri_rgb_to_3byte") ;
   if( oldim == NULL || oldim->kind != MRI_rgb ) RETURN( NULL );

   rim = mri_new_conforming( oldim , MRI_byte ) ; rr = MRI_BYTE_PTR(rim) ;
   gim = mri_new_conforming( oldim , MRI_byte ) ; gg = MRI_BYTE_PTR(gim) ;
   bim = mri_new_conforming( oldim , MRI_byte ) ; bb = MRI_BYTE_PTR(bim) ;
                                                  rgb= MRI_BYTE_PTR(oldim);
   npix = oldim->nvox ;

   for( ii=0 ; ii < npix ; ii++ ){
     rr[ii] = rgb[3*ii  ] ;
     gg[ii] = rgb[3*ii+1] ;
     bb[ii] = rgb[3*ii+2] ;
   }

   INIT_IMARR(imar) ;
   ADDTO_IMARR(imar,rim) ; ADDTO_IMARR(imar,gim) ; ADDTO_IMARR(imar,bim) ;

   RETURN( imar );
}

/*-----------------------------------------------------------------------------*/

MRI_IMAGE * mri_sharpen_rgb( float phi , MRI_IMAGE *im )
{
   MRI_IMAGE *flim , *shim , *newim ;
   byte  *iar , *nar ;
   float *sar , *far ;
   int ii , nvox , rr,gg,bb ;
   float fac ;

ENTRY("mri_sharpen_rgb") ;

   if( im == NULL ) RETURN( NULL );

   if( im->kind != MRI_rgb ) RETURN( mri_sharpen(phi,0,im) );

   flim  = mri_to_float( im ) ;                  /* intensity of input */
   shim  = mri_sharpen( phi , 0 , flim ) ;       /* sharpen intensity */
   newim = mri_new_conforming( im , MRI_rgb ) ;  /* will be output    */

   nar = MRI_BYTE_PTR(newim) ; iar = MRI_BYTE_PTR(im) ;
   far = MRI_FLOAT_PTR(flim) ; sar = MRI_FLOAT_PTR(shim) ;

   nvox = newim->nvox ;
   for( ii=0 ; ii < nvox ; ii++ ){
     if( far[ii] <= 0.0 || sar[ii] <= 0.0 ){
       nar[3*ii] = nar[3*ii+1] = nar[3*ii+2] = 0 ;
     } else {
       fac = sar[ii] / far[ii] ; /* will be positive */
       rr  = fac * iar[3*ii]   ;
       gg  = fac * iar[3*ii+1] ;
       bb  = fac * iar[3*ii+2] ;
       nar[3*ii  ] = (rr > 255) ? 255 : rr ;
       nar[3*ii+1] = (gg > 255) ? 255 : gg ;
       nar[3*ii+2] = (bb > 255) ? 255 : bb ;
     }
   }

   mri_free(flim) ; mri_free(shim) ;
   MRI_COPY_AUX(newim,im) ;
   RETURN( newim );
}

/*-----------------------------------------------------------------------------*/

MRI_IMAGE * mri_flatten_rgb( MRI_IMAGE *im )
{
   MRI_IMAGE *flim , *shim , *newim ;
   byte  *iar , *nar ;
   float *sar , *far ;
   int ii , nvox , rr,gg,bb ;
   float fac ;

ENTRY("mri_flatten_rgb") ;

   if( im == NULL ) RETURN( NULL );

   if( im->kind != MRI_rgb ) RETURN( mri_flatten(im) );

   flim  = mri_to_float( im ) ;                  /* intensity of input */
   shim  = mri_flatten( flim ) ;                 /* flatten intensity  */
   newim = mri_new_conforming( im , MRI_rgb ) ;  /* will be output     */

   nar = MRI_BYTE_PTR(newim) ; iar = MRI_BYTE_PTR(im) ;
   far = MRI_FLOAT_PTR(flim) ; sar = MRI_FLOAT_PTR(shim) ;
   nvox = newim->nvox ;

   for( ii=0 ; ii < nvox ; ii++ ){
     if( far[ii] <= 0.0 || sar[ii] <= 0.0 ){
       nar[3*ii] = nar[3*ii+1] = nar[3*ii+2] = 0 ;
     } else {
       fac = 255.9 * sar[ii] / far[ii] ; /* will be positive */
       rr  = fac * iar[3*ii]   ;
       gg  = fac * iar[3*ii+1] ;
       bb  = fac * iar[3*ii+2] ;
       nar[3*ii  ] = (rr > 255) ? 255 : rr ;
       nar[3*ii+1] = (gg > 255) ? 255 : gg ;
       nar[3*ii+2] = (bb > 255) ? 255 : bb ;
     }
   }

   mri_free(flim) ; mri_free(shim) ;
   MRI_COPY_AUX(newim,im) ;
   RETURN( newim );
}

/*-----------------------------------------------------------------------------*/

void mri_invert_inplace( MRI_IMAGE *im )
{
   register byte *bar ;
   register int ii , nbar ;

ENTRY("mri_invert_inplace") ;

   if( im == NULL ) EXRETURN ;
   switch( im->kind ){
     default: EXRETURN ;
     case MRI_byte:  nbar =   im->nvox ; bar = MRI_BYTE_PTR(im) ; break ;
     case MRI_rgb:   nbar = 3*im->nvox ; bar = MRI_RGB_PTR(im)  ; break ;
   }
   for( ii=0 ; ii < nbar ; ii++ ) bar[ii] = 255 - bar[ii] ;
   EXRETURN ;
}

/*-----------------------------------------------------------------------------*/

#ifdef SOLARIS
# define powf pow
#endif

/*** Am not sure if this works properly! ***/

void mri_gamma_rgb_inplace( float gam , MRI_IMAGE *im )  /* 15 Jan 2007 */
{
   MRI_IMAGE *flim ; byte *iar ; float *far ;
   int ii , nvox , rr,gg,bb ; float fac , val , gg1 ;

ENTRY("mri_gamma_rgb_inplace") ;

   if( im == NULL || im->kind != MRI_rgb || gam <= 0.0f ) EXRETURN ;

   flim = mri_to_float( im ) ; /* intensity of input */
   iar = MRI_BYTE_PTR(im) ; far = MRI_FLOAT_PTR(flim) ;
   fac = mri_max(flim) ;
   if( fac <= 0.0f ){ mri_free(flim); EXRETURN; } else fac = 1.0f/fac ;

   nvox = im->nvox ; gg1 = gam-1.0f ;
   for( ii=0 ; ii < nvox ; ii++ ){
     if( far[ii] <= 0.0f ){
       iar[3*ii] = iar[3*ii+1] = iar[3*ii+2] = 0 ;
     } else {
       val = powf( far[ii]*fac , gg1 ) ;
       rr  = rint(val * iar[3*ii  ]) ;
       gg  = rint(val * iar[3*ii+1]) ;
       bb  = rint(val * iar[3*ii+2]) ;
       iar[3*ii  ] = (rr > 255) ? 255 : rr ;
       iar[3*ii+1] = (gg > 255) ? 255 : gg ;
       iar[3*ii+2] = (bb > 255) ? 255 : bb ;
     }
   }

   mri_free(flim) ; EXRETURN ;
}