00001 #include "mrilib.h"
00002 
00003 /*-------------------------------------------------------------------------*/
00004 /*! Composite a collection of MRI_rgb/MRI_rgba/MRI_byte images.
00005     The first image is on top, etc.  For MRI_rgb/MRI_byte images,
00006     the default opacity is alpha in 0..1.  Black (0,0,0) pixels on input
00007     are not overlaid (unless AFNI_OVERLAY_ZERO is YES).
00008     The output image is MRI_rgb; it is composited against a black backdrop.
00009 ---------------------------------------------------------------------------*/
00010 
00011 MRI_IMAGE * mri_rgba_composite_array( MRI_IMARR *imar, float alpha )
00012 {
00013    register int npix,ii,jj , nn,nim ;
00014    MRI_IMAGE *outim , *inim ;
00015    rgbyte *outar ;
00016    float  *usop  ;
00017    int reject_zero = !AFNI_yesenv("AFNI_OVERLAY_ZERO") ;
00018 
00019 ENTRY("mri_rgba_composite") ;
00020 
00021    if( imar == NULL || IMARR_COUNT(imar) == 0 ) RETURN(NULL) ;
00022 
00023    if( alpha <= 0.0 || alpha > 1.0 ) alpha = 1.0 ;  /* default default */
00024 
00025    nim   = IMARR_COUNT(imar) ;
00026    outim = mri_new_conforming( IMARR_SUBIM(imar,0) , MRI_rgb ) ;
00027    outar = (rgbyte *) MRI_RGB_PTR(outim) ;          /* is all zero */
00028    npix  = outim->nvox ;
00029 
00030    usop  = (float *) malloc(sizeof(float)*npix) ;   /* used up opacity */
00031    for( ii=0 ; ii < npix ; ii++ ) usop[ii] = 0.0 ;
00032 
00033 #undef  MAX_OPACITY
00034 #define MAX_OPACITY 0.95
00035 
00036    for( nn=0 ; nn < nim ; nn++ ){
00037      inim = IMARR_SUBIM(imar,nn) ;
00038      if( inim->nvox < npix ) continue ;  /* bad */
00039 
00040      switch( inim->kind ){
00041        default: break ;   /* bad */
00042 
00043        case MRI_byte:{
00044          byte *inar = (byte *) MRI_BYTE_PTR(inim) , val ;
00045          register float opa ;
00046          for( ii=0 ; ii < npix ; ii++ ){
00047            if( reject_zero && inar[ii]==0 ) continue ;
00048            if( usop[ii] < MAX_OPACITY ){
00049 
00050              opa = alpha * (1.0-usop[ii]) ; usop[ii] += opa ;
00051              val = (byte)( opa * inar[ii] ) ;
00052 
00053              outar[ii].r += val ;
00054              outar[ii].g += val ;
00055              outar[ii].b += val ;
00056            }
00057          }
00058        }
00059 
00060        case MRI_rgb:{
00061          rgbyte *inar = (rgbyte *) MRI_RGB_PTR(inim) ;
00062          register float opa ;
00063          for( ii=0 ; ii < npix ; ii++ ){
00064            if( reject_zero && inar[ii].r==0
00065                            && inar[ii].g==0 && inar[ii].b==0 ) continue ;
00066            if( usop[ii] < MAX_OPACITY ){
00067 
00068              opa = alpha * (1.0-usop[ii]) ; usop[ii] += opa ;
00069 
00070              outar[ii].r += (byte)( opa * inar[ii].r ) ;
00071              outar[ii].g += (byte)( opa * inar[ii].g ) ;
00072              outar[ii].b += (byte)( opa * inar[ii].b ) ;
00073            }
00074          }
00075        }
00076        break ;
00077 
00078        case MRI_rgba:{
00079          rgba *inar = (rgba *) MRI_RGBA_PTR(inim) ;
00080          register float opa ;
00081          for( ii=0 ; ii < npix ; ii++ ){
00082            if( reject_zero && inar[ii].r==0
00083                            && inar[ii].g==0 && inar[ii].b==0 ) continue ;
00084            if( usop[ii] < MAX_OPACITY ){
00085 
00086              opa = 0.00392156*inar[ii].a * (1.0-usop[ii]) ; usop[ii] += opa ;
00087 
00088              outar[ii].r += (byte)( opa * inar[ii].r ) ;
00089              outar[ii].g += (byte)( opa * inar[ii].g ) ;
00090              outar[ii].b += (byte)( opa * inar[ii].b ) ;
00091            }
00092          }
00093        }
00094        break ;
00095      }
00096    }
00097 
00098    free(usop) ; RETURN(outim) ;
00099 }
00100 
00101 /*--------------------------------------------------------------------------*/
00102 #include <stdarg.h>
00103 /*--------------------------------------------------------------------------*/
00104 
00105 MRI_IMAGE * mri_rgba_composite_VA( float alpha, ... )
00106 {
00107    MRI_IMARR *imar=NULL ;
00108    MRI_IMAGE *im ;
00109    va_list vararg_ptr ;
00110 
00111    va_start( vararg_ptr , alpha ) ;
00112 
00113    while(1){
00114       im = va_arg( vararg_ptr , MRI_IMAGE * ) ;
00115       if( im == NULL ) break ;
00116       if( imar == NULL ) INIT_IMARR(imar) ;
00117       ADDTO_IMARR(imar,im) ;
00118    }
00119 
00120    va_end( vararg_ptr ) ;
00121 
00122    if( imar == NULL ) return NULL ;
00123    im = mri_rgba_composite_array( imar , alpha ) ;
00124 
00125    FREE_IMARR(imar) ; return im ;
00126 }
00127 
00128 /*--------------------------------------------------------------------------*/
00129 
00130 MRI_IMAGE * mri_rgba_composite_two( float alpha, MRI_IMAGE *i1, MRI_IMAGE *i2 )
00131 {
00132    MRI_IMARR *imar ; MRI_IMAGE *im ;
00133    INIT_IMARR(imar) ;
00134    ADDTO_IMARR(imar,i1) ; ADDTO_IMARR(imar,i2) ;
00135    im = mri_rgba_composite_array( imar , alpha ) ;
00136    FREE_IMARR(imar) ; return im ;
00137 }