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 "thd.h"
00009 
00010 /*---------------------------------------------------------------
00011   Routine to send a time-series (fixed index, variable ival)
00012   into a dataset - inverse function to THD_extract_series.
00013      ixyz = spatial index of desired voxel
00014           = ix + jy * n1 + kz * n1*n2
00015      npt  = # of points in array
00016      typ  = type of data in array [MRI_byte, MRI_short, MRI_float, MRI_complex]
00017      dar  = data array
00018      raw  = 0 if input is to be scaled, 1 if it is not
00019 
00020   -- RWCox - 29 Oct 1999
00021 -----------------------------------------------------------------*/
00022 
00023 void THD_insert_series( int ind , THD_3dim_dataset * dset ,
00024                         int npt , int typ , void * dar , int raw )
00025 {
00026    int nv , ival , dtyp , ii ;
00027    float * far=NULL , * fac ;
00028 
00029    if( ind < 0                ||
00030        npt <= 0               ||
00031        dar == NULL            ||
00032        !ISVALID_DSET(dset)    ||
00033        ind >= DSET_NVOX(dset) ||
00034        !DSET_IS_MALLOC(dset)    ) return ;
00035 
00036 
00037    nv = DSET_NVALS(dset) ; if( npt > nv ) npt = nv;  /* truncate input? */
00038 
00039    if( !DSET_LOADED(dset) ) DSET_load(dset) ;        /* read from disk? */
00040    if( !DSET_LOADED(dset) ) return ;
00041 
00042    dtyp = DSET_BRICK_TYPE(dset,0) ;                  /* dataset array type */
00043 
00044    /* convert input to a floating point type */
00045 
00046    if( !raw && THD_need_brick_factor(dset) )
00047       fac = dset->dblk->brick_fac ;
00048    else
00049       raw = 1 ;
00050 
00051 #define FAC(q) ( (fac[q] != 0.0) ? 1.0/fac[q] : 1.0 )
00052 
00053    if( dtyp == MRI_complex ){                             /* complex output ?! */
00054 
00055       complex * car = (complex *) malloc( sizeof(complex) * npt ) ;
00056       complex * bar ;
00057 
00058       switch( typ ){
00059          default:
00060             free(car) ; return ;   /* bad input */
00061 
00062          case MRI_complex:
00063             memcpy( car , dar , sizeof(complex)*npt ) ;
00064          break ;
00065 
00066          case MRI_float:{
00067             float * a = (float *) dar ;
00068             for( ii=0 ; ii < npt ; ii++ ){ car[ii].r = a[ii] ; car[ii].i = 0.0 ; }
00069          }
00070          break ;
00071 
00072          case MRI_short:{
00073             short * a = (short *) dar ;
00074             for( ii=0 ; ii < npt ; ii++ ){ car[ii].r = a[ii] ; car[ii].i = 0.0 ; }
00075          }
00076          break ;
00077 
00078          case MRI_byte:{
00079             byte * a = (byte *) dar ;
00080             for( ii=0 ; ii < npt ; ii++ ){ car[ii].r = a[ii] ; car[ii].i = 0.0 ; }
00081          }
00082          break ;
00083       }
00084 
00085       /* can now copy car into dataset, and exit */
00086 
00087       if( !raw )
00088          for( ii=0 ; ii < npt ; ii++ ){ car[ii].r *= FAC(ii) ; car[ii].i *= FAC(ii) ; }
00089 
00090       for( ii=0 ; ii < npt ; ii++ ){
00091          bar = (complex *) DSET_ARRAY(dset,ii) ;
00092          bar[ind] = car[ii] ;
00093       }
00094 
00095       free(car) ; return ;
00096    }
00097 
00098    /* otherwise, compute a temporary float array */
00099 
00100    far = (float *) malloc( sizeof(float) * npt ) ;
00101    switch( typ ){
00102       default:
00103          free(far) ; return ;   /* bad input */
00104 
00105       case MRI_complex:{
00106          complex * a = (complex *) dar ;
00107          for( ii=0 ; ii < npt ; ii++ ) far[ii] = CABS(a[ii]) ;
00108       }
00109       break ;
00110 
00111       case MRI_float:
00112          memcpy( far , dar , sizeof(float)*npt ) ;
00113       break ;
00114 
00115       case MRI_short:{
00116          short * a = (short *) dar ;
00117          for( ii=0 ; ii < npt ; ii++ ) far[ii] = a[ii] ;
00118       }
00119       break ;
00120 
00121       case MRI_byte:{
00122          byte * a = (byte *) dar ;
00123          for( ii=0 ; ii < npt ; ii++ ) far[ii] = a[ii] ;
00124       }
00125       break ;
00126    }
00127 
00128    if( !raw ) for( ii=0 ; ii < npt ; ii++ ) far[ii] *= FAC(ii) ;
00129 
00130    /* now convert this to the output */
00131 
00132    switch( dtyp ){
00133 
00134       default:
00135          free(far) ; return ;   /* bad dataset? */
00136 
00137       case MRI_float:{
00138          float * bar ;
00139          for( ii=0 ; ii < npt ; ii++ ){
00140             bar = (float *) DSET_ARRAY(dset,ii) ;
00141             bar[ind] = far[ii] ;
00142          }
00143       }
00144       break ;
00145 
00146       case MRI_short:{
00147          short * bar ;
00148          for( ii=0 ; ii < npt ; ii++ ){
00149             bar = (short *) DSET_ARRAY(dset,ii) ;
00150             bar[ind] = SHORTIZE(far[ii]) ;
00151          }
00152       }
00153       break ;
00154 
00155       case MRI_byte:{
00156          byte * bar ;
00157          for( ii=0 ; ii < npt ; ii++ ){
00158             bar = (byte *) DSET_ARRAY(dset,ii) ;
00159             bar[ind] = BYTEIZE(far[ii]) ;
00160          }
00161       }
00162       break ;
00163    }
00164 
00165    free(far) ; return ;
00166 }