00001 #include "mrilib.h"
00002 
00003 /****************************************************************************
00004   Functions for dealing with data extracted/inserted from rows of a 3D
00005   dataset - parallel to x, y, or z axes.
00006   -- 08 Mar 2001 - RWCox
00007 *****************************************************************************/
00008 
00009 /*---------------------------------------------------------------------------*/
00010 /*!  Get the number of elements in a row of the dataset in a particular
00011   direction given by dcode:
00012     -  +1 = x direction  -1 = reversed x direction
00013     -  +2 = y direction  -2 = reversed y direction
00014     -  +3 = z direction  -3 = reversed z direction
00015 
00016   This routine is mostly for the pitiful programmer who can't be bothered
00017   to do this calculation himself.
00018 -----------------------------------------------------------------------------*/
00019 
00020 int THD_get_dset_rowcount( THD_3dim_dataset *dset, int dcode )
00021 {
00022    if( !ISVALID_DSET(dset) ) return 0 ;        /* bad */
00023    switch( dcode ){
00024       case  1: case -1: return DSET_NX(dset) ; /* good */
00025       case  2: case -2: return DSET_NY(dset) ; /* good */
00026       case  3: case -3: return DSET_NZ(dset) ; /* good */
00027    }
00028    return 0 ;                                  /* bad */
00029 }
00030 
00031 /*---------------------------------------------------------------------------*/
00032 /*! Extract a row from a dataset sub-brick in the direction given by dcode.
00033   The 3-index of a voxel from the row is in (xx,yy,zz).  The return value
00034   is a pointer to a malloc()-ed array, whose type is given by
00035   DSET_BRICK_TYPE(dset,ival) and whose length is given by
00036   THD_get_dset_rowcount(dset,dcode).  If NULL is returned, something bad
00037   happened.
00038   N.B.: dcode < 0 ==> data is extracted in the reverse direction.
00039 -----------------------------------------------------------------------------*/
00040 
00041 void * THD_get_dset_row( THD_3dim_dataset *dset, int ival,
00042                          int dcode , int xx,int yy,int zz  )
00043 {
00044    void *row , *brick ;
00045    int nrow , kind , nx,ny,nz,nxy , kbot,kdel,kk,ii ;
00046 
00047 ENTRY("THD_get_dset_row") ;
00048 
00049    nrow = THD_get_dset_rowcount( dset , dcode ) ;
00050    if( nrow < 1 ) RETURN(NULL) ;
00051 
00052    nx = DSET_NX(dset) ;
00053    ny = DSET_NY(dset) ; nxy = nx*ny ;
00054    nz = DSET_NZ(dset) ;
00055 
00056    /*-- We will extract brick[kbot+i*kdel] for i=0..nrow-1 --*/
00057 
00058    switch( dcode ){
00059       case 1: case -1:
00060          if( yy < 0 || yy >= ny || zz < 0 || zz >= nz ) RETURN(NULL) ;
00061          kbot = yy*nx + zz*nxy ; kdel = 1 ;
00062       break ;
00063 
00064       case 2: case -2:
00065          if( xx < 0 || xx >= nx || zz < 0 || zz >= nz ) RETURN(NULL) ;
00066          kbot = xx + zz*nxy ; kdel = nx ;
00067       break ;
00068 
00069       case 3: case -3:
00070          if( xx < 0 || xx >= nx || yy < 0 || yy >= ny ) RETURN(NULL) ;
00071          kbot = xx + yy*nx ; kdel = nxy ;
00072       break ;
00073    }
00074 
00075    kind  = DSET_BRICK_TYPE(dset,ival) ;
00076    brick = DSET_ARRAY(dset,ival) ;
00077    row   = AFMALL(void, mri_datum_size((MRI_TYPE)kind) * nrow ) ;
00078 
00079    /*-- extract row, based on kind of data in sub-brick --*/
00080 
00081    switch( kind ){
00082 
00083       default: free(row) ; RETURN(NULL) ;  /* bad */
00084 
00085       case MRI_short:{
00086          short *rr = (short *)row , *bb = (short *)brick ;
00087          if( dcode > 0 )
00088             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) rr[ii] = bb[kk+kbot] ;
00089          else
00090             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) rr[nrow-1-ii] = bb[kk+kbot] ;
00091       }
00092       break ;
00093 
00094       case MRI_byte:{
00095          byte *rr = (byte *)row , *bb = (byte *)brick ;
00096          if( dcode > 0 )
00097             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) rr[ii] = bb[kk+kbot] ;
00098          else
00099             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) rr[nrow-1-ii] = bb[kk+kbot] ;
00100       }
00101       break ;
00102 
00103       case MRI_float:{
00104          float *rr = (float *)row , *bb = (float *)brick ;
00105          if( dcode > 0 )
00106             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) rr[ii] = bb[kk+kbot] ;
00107          else
00108             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) rr[nrow-1-ii] = bb[kk+kbot] ;
00109       }
00110       break ;
00111 
00112       case MRI_complex:{
00113          complex *rr = (complex *)row , *bb = (complex *)brick ;
00114          if( dcode > 0 )
00115             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) rr[ii] = bb[kk+kbot] ;
00116          else
00117             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) rr[nrow-1-ii] = bb[kk+kbot] ;
00118       }
00119       break ;
00120 
00121       case MRI_rgb:{
00122          byte *rr = (byte *)row , *bb = (byte *)brick ;
00123          if( dcode > 0 )
00124             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ){
00125                rr[3*ii  ] = bb[3*(kk+kbot)  ] ;
00126                rr[3*ii+1] = bb[3*(kk+kbot)+1] ;
00127                rr[3*ii+2] = bb[3*(kk+kbot)+2] ;
00128             }
00129          else
00130             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ){
00131                rr[3*(nrow-1-ii)  ] = bb[3*(kk+kbot)  ] ;
00132                rr[3*(nrow-1-ii)+1] = bb[3*(kk+kbot)+1] ;
00133                rr[3*(nrow-1-ii)+2] = bb[3*(kk+kbot)+2] ;
00134             }
00135       }
00136       break ;
00137    }
00138 
00139    RETURN(row) ;
00140 }
00141 
00142 /*---------------------------------------------------------------------------
00143    The inverse of THD_get_dset_row: put data back into a dataset.
00144 -----------------------------------------------------------------------------*/
00145 
00146 void THD_put_dset_row( THD_3dim_dataset *dset, int ival,
00147                        int dcode, int xx,int yy,int zz, void *row )
00148 {
00149    void *brick ;
00150    int nrow , kind , nx,ny,nz,nxy , kbot,kdel,kk,ii ;
00151 
00152 ENTRY("THD_put_dset_row") ;
00153 
00154    nrow = THD_get_dset_rowcount( dset , dcode ) ;
00155    if( nrow < 1 ) EXRETURN ;
00156 
00157    nx = DSET_NX(dset) ;
00158    ny = DSET_NY(dset) ; nxy = nx*ny ;
00159    nz = DSET_NZ(dset) ;
00160 
00161    /*-- We will insert brick[kbot+i*kdel] for i=0..nrow-1 --*/
00162 
00163    switch( dcode ){
00164       case 1: case -1:
00165          if( yy < 0 || yy >= ny || zz < 0 || zz >= nz ) EXRETURN ;
00166          kbot = yy*nx + zz*nxy ; kdel = 1 ;
00167       break ;
00168 
00169       case 2: case -2:
00170          if( xx < 0 || xx >= nx || zz < 0 || zz >= nz ) EXRETURN ;
00171          kbot = xx + zz*nxy ; kdel = nx ;
00172       break ;
00173 
00174       case 3: case -3:
00175          if( xx < 0 || xx >= nx || yy < 0 || yy >= ny ) EXRETURN ;
00176          kbot = xx + yy*nx ; kdel = nxy ;
00177       break ;
00178    }
00179 
00180    kind  = DSET_BRICK_TYPE(dset,ival) ;
00181    brick = DSET_ARRAY(dset,ival) ;
00182 
00183    /*-- insert row, based on kind of data in sub-brick --*/
00184 
00185    switch( kind ){
00186 
00187       default: EXRETURN ;  /* bad */
00188 
00189       case MRI_short:{
00190          short *rr = (short *)row , *bb = (short *)brick ;
00191          if( dcode > 0 )
00192             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) bb[kk+kbot] = rr[ii] ;
00193          else
00194             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) bb[kk+kbot] = rr[nrow-1-ii] ;
00195       }
00196       break ;
00197 
00198       case MRI_byte:{
00199          byte *rr = (byte *)row , *bb = (byte *)brick ;
00200          if( dcode > 0 )
00201             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) bb[kk+kbot] = rr[ii] ;
00202          else
00203             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) bb[kk+kbot] = rr[nrow-1-ii] ;
00204       }
00205       break ;
00206 
00207       case MRI_complex:{
00208          complex *rr = (complex *)row , *bb = (complex *)brick ;
00209          if( dcode > 0 )
00210             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) bb[kk+kbot] = rr[ii] ;
00211          else
00212             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) bb[kk+kbot] = rr[nrow-1-ii] ;
00213       }
00214       break ;
00215 
00216       case MRI_float:{
00217          float *rr = (float *)row , *bb = (float *)brick ;
00218          if( dcode > 0 )
00219             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) bb[kk+kbot] = rr[ii] ;
00220          else
00221             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ) bb[kk+kbot] = rr[nrow-1-ii] ;
00222       }
00223       break ;
00224 
00225       case MRI_rgb:{
00226          byte *rr = (byte *)row , *bb = (byte *)brick ;
00227          if( dcode > 0 )
00228             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ){
00229                bb[3*(kk+kbot)  ] = rr[3*ii  ] ;
00230                bb[3*(kk+kbot)+1] = rr[3*ii+1] ;
00231                bb[3*(kk+kbot)+2] = rr[3*ii+2] ;
00232             }
00233          else
00234             for( ii=kk=0 ; ii < nrow ; ii++,kk+=kdel ){
00235                bb[3*(kk+kbot)  ] = rr[3*(nrow-1-ii)  ] ;
00236                bb[3*(kk+kbot)+1] = rr[3*(nrow-1-ii)+1] ;
00237                bb[3*(kk+kbot)+2] = rr[3*(nrow-1-ii)+2] ;
00238             }
00239       }
00240       break ;
00241    }
00242 
00243    EXRETURN ;
00244 }