Doxygen Source Code Documentation

Main Page Alphabetical List Data Structures File List Data Fields Globals Search

thd_rot3d_byte.c File Reference

#include "thd_shear3d.h"


Defines
#define	CACHE 7168
#define	TSBOT 0.3
#define	TSTOP 0.7
#define	NNBOT 0.5
#define	DTYPE byte
#define	DSIZE 1
#define	VV(i, j, k) v[(i)+(j)nx+(k)nxy]
#define	SX(i) (nx1-(i))
#define	SY(j) (ny1-(j))
#define	SZ(k) (nz1-(k))
Functions
void	THD_rota_byte_mode (int code)
int	nn_shift_byte (int n, float af, DTYPE *f)
int	ts_shift_byte (int n, float af, DTYPE *f)
void	flip_xy (int nx, int ny, int nz, DTYPE v, Tmask tm)
void	flip_yz (int nx, int ny, int nz, DTYPE v, Tmask tm)
void	flip_xz (int nx, int ny, int nz, DTYPE v, Tmask tm)
void	apply_xshear (float a, float b, float s, int nx, int ny, int nz, DTYPE v, Tmask tm)
void	apply_yshear (float a, float b, float s, int nx, int ny, int nz, DTYPE v, Tmask tm)
void	apply_zshear (float a, float b, float s, int nx, int ny, int nz, DTYPE v, Tmask tm)
void	apply_3shear (MCW_3shear shr, int nx, int ny, int nz, DTYPE vol, Tmask tm)
void	THD_rota_vol_byte (int nx, int ny, int nz, float xdel, float ydel, float zdel, DTYPE vol, int ax1, float th1, int ax2, float th2, int ax3, float th3, int dcode, float dx, float dy, float dz, Tmask tm)
Variables
int	icode = MRI_TSSHIFT
float	sbot = TSBOT
int	nlcbuf = 0
DTYPE *	lcbuf = NULL

Define Documentation

#define CACHE 7168

Definition at line 15 of file thd_rot3d_byte.c.

Referenced by apply_yshear(), and apply_zshear().

#define DSIZE 1

Definition at line 41 of file thd_rot3d_byte.c.

Referenced by apply_yshear(), apply_zshear(), flip_xy(), flip_xz(), flip_yz(), nn_shift_byte(), and ts_shift_byte().

#define DTYPE byte

Definition at line 39 of file thd_rot3d_byte.c.

Referenced by apply_3shear(), apply_xshear(), apply_yshear(), apply_zshear(), flip_xy(), flip_xz(), flip_yz(), nn_shift_byte(), THD_rota_vol_byte(), and ts_shift_byte().

#define NNBOT 0.5

Definition at line 20 of file thd_rot3d_byte.c.

Referenced by apply_yshear(), apply_zshear(), nn_shift_byte(), and THD_rota_byte_mode().

#define SX

(

)

(nx1-(i))

Definition at line 150 of file thd_rot3d_byte.c.

#define SY

(

)

(ny1-(j))

Definition at line 151 of file thd_rot3d_byte.c.

#define SZ

(

)

(nz1-(k))

Definition at line 152 of file thd_rot3d_byte.c.

#define TSBOT 0.3

Definition at line 17 of file thd_rot3d_byte.c.

Referenced by apply_yshear(), apply_zshear(), THD_rota_byte_mode(), and ts_shift_byte().

#define TSTOP 0.7

Definition at line 18 of file thd_rot3d_byte.c.

Referenced by ts_shift_byte().

#define VV	(	i,
		j,
		k	)	v[(i)+(j)nx+(k)nxy]

Definition at line 149 of file thd_rot3d_byte.c.

Function Documentation

void apply_3shear	(	MCW_3shear	shr,
		int	nx,
		int	ny,
		int	nz,
		DTYPE *	vol,
		Tmask *	tm
	)	`[static]`

Definition at line 423 of file thd_rot3d_byte.c.

References a, apply_xshear(), apply_yshear(), apply_zshear(), MCW_3shear::ax, DTYPE, MCW_3shear::flip0, MCW_3shear::flip1, flip_xy(), flip_xz(), flip_yz(), ISVALID_3SHEAR, nz, MCW_3shear::scl, and MCW_3shear::sft.

Referenced by THD_rota_vol(), THD_rota_vol_2byte(), THD_rota_vol_byte(), THD_rota_vol_matvec(), and THD_rota_vol_matvec_2byte().

00425 {
00426    int qq ;
00427    float a , b , s ;
00428 
00429    if( ! ISVALID_3SHEAR(shr) ) return ;
00430 
00431    /* carry out a preliminary 180 flippo ? */
00432 
00433    if( shr.flip0 >= 0 ){
00434       switch( shr.flip0 + shr.flip1 ){
00435          case 1: flip_xy( nx,ny,nz,vol,tm ) ; break ;
00436          case 2: flip_xz( nx,ny,nz,vol,tm ) ; break ;
00437          case 3: flip_yz( nx,ny,nz,vol,tm ) ; break ;
00438       }
00439    }
00440 
00441    /* apply each shear */
00442 
00443    for( qq=0 ; qq < 4 ; qq++ ){
00444       switch( shr.ax[qq] ){
00445          case 0:
00446             a = shr.scl[qq][1] ;
00447             b = shr.scl[qq][2] ;
00448             s = shr.sft[qq]    ;
00449             apply_xshear( a,b,s , nx,ny,nz , vol , (qq==0)? tm : NULL ) ;
00450          break ;
00451 
00452          case 1:
00453             a = shr.scl[qq][0] ;
00454             b = shr.scl[qq][2] ;
00455             s = shr.sft[qq]    ;
00456             apply_yshear( a,b,s , nx,ny,nz , vol , (qq==0)? tm : NULL ) ;
00457          break ;
00458 
00459          case 2:
00460             a = shr.scl[qq][0] ;
00461             b = shr.scl[qq][1] ;
00462             s = shr.sft[qq]    ;
00463             apply_zshear( a,b,s , nx,ny,nz , vol , (qq==0)? tm : NULL ) ;
00464          break ;
00465       }
00466    }
00467 
00468    return ;
00469 }

void apply_xshear	(	float	a,
		float	b,
		float	s,
		int	nx,
		int	ny,
		int	nz,
		DTYPE *	v,
		Tmask *	tm
	)	`[static]`

Definition at line 247 of file thd_rot3d_byte.c.

References a, DTYPE, MRI_NN, MRI_TSSHIFT, nn_shift_byte(), nz, sbot, TM_XLINE, ts_shift_byte(), and v.

Referenced by apply_3shear().

00249 {
00250    DTYPE * fj0 ;
00251    int   nx1=nx-1    , ny1=ny-1    , nz1=nz-1    , nxy=nx*ny ;
00252    float nx2=0.5*nx1 , ny2=0.5*ny1 , nz2=0.5*nz1 ;
00253    int ii,jj,kk ;
00254    float st ;
00255 
00256    /* don't do anything if shift is too small */
00257 
00258    st = fabs(a)*ny2 + fabs(b)*nz2 + fabs(s); if( st < sbot ) return ;
00259 
00260    switch( icode ){
00261       default:
00262       case MRI_TSSHIFT:
00263         for( kk=0 ; kk < nz ; kk++ ){
00264           for( jj=0 ; jj < ny ; jj++ )
00265             if( TM_XLINE(tm,jj+kk*ny) )
00266               ts_shift_byte( nx, a*(jj-ny2)+b*(kk-nz2)+s, v+(jj*nx+kk*nxy) );
00267         }
00268       break ;
00269 
00270       case MRI_NN:
00271         for( kk=0 ; kk < nz ; kk++ ){
00272           for( jj=0 ; jj < ny ; jj++ )
00273             if( TM_XLINE(tm,jj+kk*ny) )
00274               nn_shift_byte( nx, a*(jj-ny2)+b*(kk-nz2)+s, v+(jj*nx+kk*nxy) );
00275         }
00276       break ;
00277    }
00278 
00279    return ;
00280 }

void apply_yshear	(	float	a,
		float	b,
		float	s,
		int	nx,
		int	ny,
		int	nz,
		DTYPE *	v,
		Tmask *	tm
	)	`[static]`

Definition at line 286 of file thd_rot3d_byte.c.

References a, CACHE, DSIZE, DTYPE, free, malloc, MIN, MRI_NN, MRI_TSSHIFT, nn_shift_byte(), NNBOT, nz, sbot, TM_YLINE, ts_shift_byte(), TSBOT, v, and VV.

Referenced by apply_3shear().

00288 {
00289    DTYPE * fj0 ;
00290    int   nx1=nx-1    , ny1=ny-1    , nz1=nz-1    , nxy=nx*ny ;
00291    float nx2=0.5*nx1 , ny2=0.5*ny1 , nz2=0.5*nz1 ;
00292    int ii,jj,kk ;
00293    float st ;
00294    int xnum , xx , xtop , *wk ;
00295 
00296    /* don't do anything if shift is too small */
00297 
00298    st = fabs(a)*nx2 + fabs(b)*nz2 + fabs(s) ; if( st < sbot ) return ;
00299 
00300    xnum = CACHE / (ny*DSIZE) ; if( xnum < 1 ) xnum = 1 ;
00301    fj0 = (DTYPE *) malloc( DSIZE * xnum*ny ) ;
00302    wk  = (int *)   malloc( sizeof(int)*xnum ) ;
00303 
00304    switch( icode ){
00305       default:
00306       case MRI_TSSHIFT:
00307         for( kk=0 ; kk < nz ; kk++ ){
00308           for( ii=0 ; ii < nx ; ii+=xnum ){
00309             xtop = MIN(nx-ii,xnum) ;
00310             for( xx=0 ; xx < xtop ; xx++ )
00311               wk[xx] = fabs(a*(ii+xx-nx2)+b*(kk-nz2)+s) > TSBOT
00312                        && TM_YLINE(tm,kk+(ii+xx)*nz) ;
00313             for( jj=0; jj < ny; jj++ )
00314               for( xx=0 ; xx < xtop ; xx++ )
00315                 if( wk[xx] ) fj0[jj+xx*ny] = VV(ii+xx,jj,kk) ;
00316             for( xx=0 ; xx < xtop ; xx++ )
00317               if( wk[xx] )
00318                wk[xx] = ts_shift_byte(ny, a*(ii+xx-nx2)+b*(kk-nz2)+s, fj0+xx*ny);
00319             for( jj=0; jj < ny; jj++ )
00320               for( xx=0 ; xx < xtop ; xx++ )
00321                 if( wk[xx] ) VV(ii+xx,jj,kk) = fj0[jj+xx*ny] ;
00322           }
00323         }
00324       break ;
00325 
00326       case MRI_NN:
00327         for( kk=0 ; kk < nz ; kk++ ){
00328           for( ii=0 ; ii < nx ; ii+=xnum ){
00329             xtop = MIN(nx-ii,xnum) ;
00330             for( xx=0 ; xx < xtop ; xx++ )
00331               wk[xx] = fabs(a*(ii+xx-nx2)+b*(kk-nz2)+s) > NNBOT
00332                        && TM_YLINE(tm,kk+(ii+xx)*nz) ;
00333             for( jj=0; jj < ny; jj++ )
00334               for( xx=0 ; xx < xtop ; xx++ )
00335                 if( wk[xx] ) fj0[jj+xx*ny] = VV(ii+xx,jj,kk) ;
00336             for( xx=0 ; xx < xtop ; xx++ )
00337               if( wk[xx] )
00338                wk[xx] = nn_shift_byte(ny, a*(ii+xx-nx2)+b*(kk-nz2)+s, fj0+xx*ny);
00339             for( jj=0; jj < ny; jj++ )
00340               for( xx=0 ; xx < xtop ; xx++ )
00341                 if( wk[xx] ) VV(ii+xx,jj,kk) = fj0[jj+xx*ny] ;
00342           }
00343         }
00344       break ;
00345    }
00346 
00347    free(wk) ; free(fj0) ; return ;
00348 }

void apply_zshear	(	float	a,
		float	b,
		float	s,
		int	nx,
		int	ny,
		int	nz,
		DTYPE *	v,
		Tmask *	tm
	)	`[static]`

Definition at line 354 of file thd_rot3d_byte.c.

References a, CACHE, DSIZE, DTYPE, free, malloc, MIN, MRI_NN, MRI_TSSHIFT, nn_shift_byte(), NNBOT, nz, sbot, TM_ZLINE, ts_shift_byte(), TSBOT, v, and VV.

Referenced by apply_3shear().

00356 {
00357    DTYPE * fj0 ;
00358    int   nx1=nx-1    , ny1=ny-1    , nz1=nz-1    , nxy=nx*ny ;
00359    float nx2=0.5*nx1 , ny2=0.5*ny1 , nz2=0.5*nz1 ;
00360    int ii,jj,kk ;
00361    float st ;
00362    int xnum , xx , xtop , *wk ;
00363 
00364    /* don't do anything if shift is too small */
00365 
00366    st = fabs(a)*nx2 + fabs(b)*ny2 + fabs(s) ; if( st < sbot ) return ;
00367 
00368    xnum = CACHE / (nz*DSIZE) ; if( xnum < 1 ) xnum = 1 ;
00369    fj0 = (DTYPE *) malloc( DSIZE * xnum*nz ) ;
00370    wk  = (int *)   malloc( sizeof(int)*xnum ) ;
00371 
00372    switch( icode ){
00373       default:
00374       case MRI_TSSHIFT:
00375         for( jj=0 ; jj < ny ; jj++ ){
00376           for( ii=0 ; ii < nx ; ii+=xnum ){
00377             xtop = MIN(nx-ii,xnum) ;
00378             for( xx=0 ; xx < xtop ; xx++ )
00379                wk[xx] = fabs(a*(ii+xx-nx2)+b*(jj-ny2)+s) > TSBOT
00380                         && TM_ZLINE(tm,ii+jj*nx+xx) ;
00381             for( kk=0; kk < nz; kk++ )
00382               for( xx=0 ; xx < xtop ; xx++ )
00383                 if( wk[xx] ) fj0[kk+xx*nz] = VV(ii+xx,jj,kk) ;
00384             for( xx=0 ; xx < xtop ; xx++ )
00385               if( wk[xx] )
00386                wk[xx] = ts_shift_byte(nz, a*(ii+xx-nx2)+b*(jj-ny2)+s, fj0+xx*nz);
00387             for( kk=0; kk < nz; kk++ )
00388               for( xx=0 ; xx < xtop ; xx++ )
00389                 if( wk[xx] ) VV(ii+xx,jj,kk) = fj0[kk+xx*nz] ;
00390           }
00391         }
00392       break ;
00393 
00394       case MRI_NN:
00395         for( jj=0 ; jj < ny ; jj++ ){
00396           for( ii=0 ; ii < nx ; ii+=xnum ){
00397             xtop = MIN(nx-ii,xnum) ;
00398             for( xx=0 ; xx < xtop ; xx++ )
00399                wk[xx] = fabs(a*(ii+xx-nx2)+b*(jj-ny2)+s) > NNBOT
00400                         && TM_ZLINE(tm,ii+jj*nx+xx) ;
00401             for( kk=0; kk < nz; kk++ )
00402               for( xx=0 ; xx < xtop ; xx++ )
00403                 if( wk[xx] ) fj0[kk+xx*nz] = VV(ii+xx,jj,kk) ;
00404             for( xx=0 ; xx < xtop ; xx++ )
00405               if( wk[xx] )
00406                wk[xx] = nn_shift_byte(nz, a*(ii+xx-nx2)+b*(jj-ny2)+s, fj0+xx*nz);
00407             for( kk=0; kk < nz; kk++ )
00408               for( xx=0 ; xx < xtop ; xx++ )
00409                 if( wk[xx] ) VV(ii+xx,jj,kk) = fj0[kk+xx*nz] ;
00410           }
00411         }
00412       break ;
00413    }
00414 
00415    free(wk) ; free(fj0) ; return ;
00416 }

void flip_xy	(	int	nx,
		int	ny,
		int	nz,
		DTYPE *	v,
		Tmask *	tm
	)	`[static]`

Definition at line 154 of file thd_rot3d_byte.c.

References DSIZE, DTYPE, free, malloc, nz, SX, SY, TM_XLINE, v, and VV.

Referenced by apply_3shear().

00155 {
00156    int ii,jj,kk ;
00157    int nx1=nx-1,nx2=nx/2, ny1=ny-1,ny2=ny/2, nz1=nz-1,nz2=nz/2, nxy=nx*ny ;
00158    DTYPE * r1 ;
00159 
00160    r1 = (DTYPE *) malloc(DSIZE*nx) ;  /* save 1 row */
00161 
00162    for( kk=0 ; kk < nz ; kk++ ){              /* for each slice */
00163       for( jj=0 ; jj < ny2 ; jj++ ){          /* first 1/2 of rows */
00164 
00165          /* swap rows jj and ny1-jj, flipping them in ii as well */
00166 
00167          if( TM_XLINE(tm,jj+kk*ny) || TM_XLINE(tm,SY(jj)+kk*ny) ){
00168             for( ii=0; ii < nx; ii++ ) r1[ii]           = VV(SX(ii),SY(jj),kk) ;
00169             for( ii=0; ii < nx; ii++ ) VV(ii,SY(jj),kk) = VV(SX(ii),jj    ,kk) ;
00170             for( ii=0; ii < nx; ii++ ) VV(ii,jj    ,kk) = r1[ii] ;
00171          }
00172       }
00173       if( ny%2 == 1 && TM_XLINE(tm,jj+kk*ny) ){  /* central row? */
00174          for( ii=0; ii < nx; ii++ ) r1[ii]       = VV(SX(ii),jj,kk); /* flip it */
00175          for( ii=0; ii < nx; ii++ ) VV(ii,jj,kk) = r1[ii] ;          /* restore */
00176       }
00177    }
00178 
00179    free(r1) ; return ;
00180 }

void flip_xz	(	int	nx,
		int	ny,
		int	nz,
		DTYPE *	v,
		Tmask *	tm
	)	`[static]`

Definition at line 217 of file thd_rot3d_byte.c.

References DSIZE, DTYPE, free, malloc, nz, SX, SZ, TM_XLINE, v, and VV.

Referenced by apply_3shear().

00218 {
00219    int ii,jj,kk ;
00220    int nx1=nx-1,nx2=nx/2, ny1=ny-1,ny2=ny/2, nz1=nz-1,nz2=nz/2, nxy=nx*ny ;
00221    DTYPE * r1 ;
00222 
00223    r1 = (DTYPE *) malloc(DSIZE*nx) ;
00224 
00225    for( jj=0 ; jj < ny ; jj++ ){
00226       for( kk=0 ; kk < nz2 ; kk++ ){
00227          if( TM_XLINE(tm,jj+kk*ny) || TM_XLINE(tm,jj+SZ(kk)*ny) ){
00228             for( ii=0; ii < nx; ii++ ) r1[ii]           = VV(SX(ii),jj,SZ(kk)) ;
00229             for( ii=0; ii < nx; ii++ ) VV(ii,jj,SZ(kk)) = VV(SX(ii),jj,kk    ) ;
00230             for( ii=0; ii < nx; ii++ ) VV(ii,jj,kk    ) = r1[ii] ;
00231          }
00232       }
00233       if( nz%2 == 1 && TM_XLINE(tm,jj+kk*ny) ){
00234          for( ii=0; ii < nx; ii++ ) r1[ii]       = VV(SX(ii),jj,kk) ;
00235          for( ii=0; ii < nx; ii++ ) VV(ii,jj,kk) = r1[ii] ;
00236       }
00237    }
00238 
00239    free(r1) ; return ;
00240 }

void flip_yz	(	int	nx,
		int	ny,
		int	nz,
		DTYPE *	v,
		Tmask *	tm
	)	`[static]`

Definition at line 187 of file thd_rot3d_byte.c.

References DSIZE, DTYPE, free, malloc, nz, SY, SZ, TM_YLINE, v, and VV.

Referenced by apply_3shear().

00188 {
00189    int ii,jj,kk ;
00190    int nx1=nx-1,nx2=nx/2, ny1=ny-1,ny2=ny/2, nz1=nz-1,nz2=nz/2, nxy=nx*ny ;
00191    DTYPE * r1 ;
00192 
00193    r1 = (DTYPE *) malloc(DSIZE*ny) ;
00194 
00195    for( ii=0 ; ii < nx ; ii++ ){
00196       for( kk=0 ; kk < nz2 ; kk++ ){
00197          if( TM_YLINE(tm,kk+ii*nz) || TM_YLINE(tm,SZ(kk)+ii*nz) ){
00198             for( jj=0; jj < ny; jj++ ) r1[jj]           = VV(ii,SY(jj),SZ(kk)) ;
00199             for( jj=0; jj < ny; jj++ ) VV(ii,jj,SZ(kk)) = VV(ii,SY(jj),kk    ) ;
00200             for( jj=0; jj < ny; jj++ ) VV(ii,jj,kk    ) = r1[jj] ;
00201          }
00202       }
00203       if( nz%2 == 1 && TM_YLINE(tm,kk+ii*nz) ){
00204          for( jj=0; jj < ny; jj++ ) r1[jj]       = VV(ii,SY(jj),kk) ;
00205          for( jj=0; jj < ny; jj++ ) VV(ii,jj,kk) = r1[jj] ;
00206       }
00207    }
00208 
00209    free(r1) ; return ;
00210 }

int nn_shift_byte	(	int	n,
		float	af,
		DTYPE *	f
	)	`[static]`

Definition at line 48 of file thd_rot3d_byte.c.

References DSIZE, DTYPE, free, lcbuf, malloc, nlcbuf, and NNBOT.

Referenced by apply_xshear(), apply_yshear(), and apply_zshear().

00049 {
00050    register int ii , ia ;
00051    float aa ;
00052    int ibot,itop ;
00053 
00054    if( fabs(af) < NNBOT ) return 0 ; /* do nothing if shift is too small */
00055 
00056    for( ii=0 ; ii < n && f[ii] == 0 ; ii++ ) ; /* nada */
00057    if( ii == n ) return 0 ;          /* do nothing if data all zero */
00058 
00059    af = -af ; ia = (int) af ; if( af < 0 ) ia-- ;  /* ia = floor */
00060    aa = af - ia ;
00061 
00062    if( n > nlcbuf ){
00063       if( lcbuf != NULL ) free(lcbuf) ;
00064       lcbuf  = (DTYPE *) malloc( DSIZE * n ) ;
00065       nlcbuf = n ;
00066    }
00067 
00068    ibot = -ia  ;   if( ibot < 0   ) ibot = 0 ;
00069    itop = n-2-ia ; if( itop > n-1 ) itop = n-1 ;
00070 
00071 #if 1
00072    memset(lcbuf,0,n*DSIZE) ;   /* seems to be faster */
00073 #else
00074    memset(lcbuf,0,ibot*DSIZE) ;
00075    memset(lcbuf+(itop+1),0,(n-(itop+1))*DSIZE) ;
00076 #endif
00077 
00078    if( aa < NNBOT ){         /* NN to bottom */
00079 
00080       memcpy( lcbuf+ibot, f+(ibot+ia)  , (itop+1-ibot)*DSIZE ) ;
00081 
00082    } else {                  /* NN to top */
00083 
00084       memcpy( lcbuf+ibot, f+(ibot+1+ia), (itop+1-ibot)*DSIZE ) ;
00085 
00086    }
00087    memcpy( f , lcbuf , DSIZE*n ) ;
00088    return 1 ;
00089 }

void THD_rota_byte_mode

(

int

code

)

Definition at line 27 of file thd_rot3d_byte.c.

References icode, MRI_NN, MRI_TSSHIFT, NNBOT, sbot, and TSBOT.

00028 {
00029    if( code == MRI_NN ){
00030       icode = MRI_NN      ; sbot = NNBOT ;
00031    } else {
00032       icode = MRI_TSSHIFT ; sbot = TSBOT ;
00033    }
00034 }

void THD_rota_vol_byte	(	int	nx,
		int	ny,
		int	nz,
		float	xdel,
		float	ydel,
		float	zdel,
		DTYPE *	vol,
		int	ax1,
		float	th1,
		int	ax2,
		float	th2,
		int	ax3,
		float	th3,
		int	dcode,
		float	dx,
		float	dy,
		float	dz,
		Tmask *	tm
	)

Definition at line 475 of file thd_rot3d_byte.c.

References apply_3shear(), DTYPE, ISVALID_3SHEAR, nz, and rot_to_shear().

00479 {
00480    MCW_3shear shr ;
00481 
00482    if( nx < 2 || ny < 2 || nz < 2 || vol == NULL ) return ;
00483 
00484    if( xdel == 0.0 ) xdel = 1.0 ;
00485    if( ydel == 0.0 ) ydel = 1.0 ;
00486    if( zdel == 0.0 ) zdel = 1.0 ;
00487 
00488    if( th1 == 0.0 && th2 == 0.0 && th3 == 0.0 ){  /* nudge rotation */
00489       th1 = 1.e-6 ; th2 = 1.1e-6 ; th3 = 0.9e-6 ;
00490    }
00491 
00492    shr = rot_to_shear( ax1,-th1 , ax2,-th2 , ax3,-th3 ,
00493                        dcode,dx,dy,dz , xdel,ydel,zdel ) ;
00494 
00495    if( ! ISVALID_3SHEAR(shr) ){
00496       fprintf(stderr,"*** THD_rota_vol_byte: can't compute shear transformation!\n") ;
00497       return ;
00498    }
00499 
00500    /*****************************************/
00501 
00502    apply_3shear( shr , nx,ny,nz , vol , tm ) ;
00503 
00504    /*****************************************/
00505 
00506    return ;
00507 }

int ts_shift_byte	(	int	n,
		float	af,
		DTYPE *	f
	)	`[static]`

Definition at line 95 of file thd_rot3d_byte.c.

References DSIZE, DTYPE, free, lcbuf, malloc, nlcbuf, TSBOT, and TSTOP.

Referenced by apply_xshear(), apply_yshear(), and apply_zshear().

00096 {
00097    register int ii , ia , ix ;
00098    float aa ;
00099    int ibot,itop ;
00100 
00101    if( fabs(af) < TSBOT ) return 0 ; /* do nothing if shift is too small */
00102 
00103    for( ii=0 ; ii < n && f[ii] == 0 ; ii++ ) ; /* nada */
00104    if( ii == n ) return 0 ;          /* do nothing if data all zero */
00105 
00106    af = -af ; ia = (int) af ; if( af < 0 ) ia-- ;  /* ia = floor */
00107    aa = af - ia ;
00108 
00109    if( n > nlcbuf ){
00110       if( lcbuf != NULL ) free(lcbuf) ;
00111       lcbuf  = (DTYPE *) malloc( DSIZE * n ) ;
00112       nlcbuf = n ;
00113    }
00114 
00115    ibot = -ia  ;   if( ibot < 0   ) ibot = 0 ;
00116    itop = n-2-ia ; if( itop > n-1 ) itop = n-1 ;
00117 
00118 #if 1
00119    memset(lcbuf,0,n*DSIZE) ;   /* seems to be faster */
00120 #else
00121    memset(lcbuf,0,ibot*DSIZE) ;
00122    memset(lcbuf+(itop+1),0,(n-(itop+1))*DSIZE) ;
00123 #endif
00124 
00125    if( aa < TSBOT ){         /* NN to bottom */
00126 
00127       memcpy( lcbuf+ibot, f+(ibot+ia)  , (itop+1-ibot)*DSIZE ) ;
00128 
00129    } else if( aa > TSTOP ){  /* NN to top */
00130 
00131       memcpy( lcbuf+ibot, f+(ibot+1+ia), (itop+1-ibot)*DSIZE ) ;
00132 
00133    } else {                  /* average bottom and top */
00134 
00135       for( ii=ibot ; ii <= itop ; ii++ ){
00136          ix = ii + ia ; lcbuf[ii] = ( f[ix] + f[ix+1] ) >> 1 ;
00137       }
00138 
00139    }
00140    memcpy( f , lcbuf , DSIZE*n ) ;
00141    return 1 ;
00142 }