Transform matrices are confusing!  There, I said it.  If you’ve never taken the time to play around with transform matrices in MRI, I completely understand.  That said, it’s not a bad idea to get some exposure to the world of warping and the matrices that they often depend on.  First of all, there are different types of transforms.  We tend to measure them in terms of how many parameters are allowed to vary (called Degrees of Freedom).

Linear Transforms

In AFNI, one of the most common transforms is a linear affine transform, which has 12 degrees of freedom.  There are a few AFNI programs for performing affine transforms, depending on what transform you are interested in computing.  If you wish to align the EPI (functional) runs to the anatomical dataset, you can use 3dAllineate or align_epi_anat.py (which calls 3dAllineate after some processing steps).  I recommend align_epi_anat.py since it gives me better registrations with default options than just calling 3dAllineate.

align_epi_anat.py \
-anat anat+orig. \
-epi epi+orig. \
-epi_base 0 \
-epi2anat \
-giant_move

If you wanted to do an affine transform to standard space (TLRC or MNI), you can use @auto_tlrc, 3dAllineate, or align_epi_anat.py.  I recommend @auto_tlrc, as it gives me the best ANAT–>TLRC/MNI transformations.

@auto_tlrc -base TT_N27+tlrc. -input anat+orig

If we knew that our data often had very different CENTER points, measured by @Center_Distance, we could modify the above command to automatically align the centers of the dataset before beginning the transform via the init_xform option!

@auto_tlrc -base TT_N27+tlrc. -input anat+orig -init_xform CENTER

Using align_epi_anat.py and @auto_tlrc are also the defaults if you use afni_proc.py with the align and tlrc blocks.  And if you aren’t currently using afni_proc.py, I would highly recommend looking into it!

Nonlinear Transforms

In addition to linear transforms, AFNI “recently” (read: in 2013) added a new program for performing nonlinear warps (3dQwarp).  There is also a python wrapper script (auto_align.py), which will pair an affine transform and the nonlinear transform, similar to SPM’s DARTEL transform (J. Ashburner. A Fast Diffeomorphic Image Registration Algorithm. NeuroImage, 38(1):95-113, 2007.).  I highly recommend using auto_align.py for your nonlinear transform needs.

One important note is that you can call 3dQwarp with an -allineate option which will use 3dAllineate to do a linear affine transform prior to doing the nonlinear warping step.  Here’s where things start to get a bit tricky!  If you use 3dQwarp with the -allineate option, then the output transformations are automatically concatenated for you!  That means you get to skip the arguably “yucky” stuff that I’m going to talk about below.  However, if you use auto_warp.py, you will benefit from a lot of automatic options being applied (that likely will help your registration), at the cost of then having to concatenate your transforms!  But it’s really not that bad!

Concatenating and Applying Transforms

Why concatenate your transforms together when you could just apply them separately?  Well it’s usually a good idea to perform as few warping operations on your data as possible, so that you only resample (interpolate) your data a single time.  To combine these affine and nonlinear warps is fairly straightforward by following a of steps:

1.  Setup initial warp of original subject data to TT_N27 template:

auto_warp.py -base TT_N27+tlrc -input anat+orig -skull_strip_input yes

Even though auto_warp.py has given us the necessary files, as an exercise here you can try applying the matrices/warps to recreate the process!  Here we apply the combined affine and nonlinear warps on the original (skull-stripped) anatomical in order to warp to TT_N27:

3dNwarpApply -master TT_N27+tlrc \
-source subject_anatomical+orig \
-nwarp 'awpy/anat.un.aff.qw_WARP.nii anat.un.aff.Xat.1D' \
-prefix subject_anatomical_MNI

If you wanted to warp your EPI data to include the motion parameters, EPI–>ANAT transformation, and ANAT–>MNI you could concatenate all of them together to give you a single interpolation.  More on that later (though you can read ahead and look at how afni_proc.py does it!).

Is interpolation really that bad?

Some people think so.  But it happens one way or another!  You’re interpolating during slice time correction, motion correction, any type of transform, and possibly during other mathematical operations (like smoothing) depending.  The best you can do is try to reduce the number of interpolations, which afni_proc.py does for you.

Where do we go from here?

I recommend reading the cat_matvec help as well as the help for 3dAllineate and 3dQwarp.  Though likely you’ll be applying the transforms using 3dNwarpApply, which has a new option -iwarp, which will invert the transform of the warps supplied to it!

I think we’ve all had that moment where we wonder what exactly our HRF function is doing to give us the results that we see in our data.  Using a fixed function regressor can be great for a number of reasons: 1) they don’t require many degrees of freedom, 2) someone else did the hard work to figure them out, 3) they often do a pretty good job of modeling the hemodynamic response that has been well documented.  Yet every so often we want to know what the actual response looks like, either to double check our Gamma function style HRFs or possibly because we’re interested in aspects of the shape of the actual response.  Consider this a quick introduction to some options you have when using TENT functions for estimating the shape of the blood flow response directly from the data.

First and foremost, it’s not always necessary to go back and rerun all of your data (including preprocessing) using a new afni_proc.py script.  Instead you can use a modified script to just take your already preprocessed data and run only the regression step (see how here).  Great, well that just saved you a ton of time, so head over to the 3dDeconvolve 2004 upgrades page and take a peek at some of the “newer” possibilities.

Basic TENTs

Now that you’ve read that, let’s take a quick second to look at some of the essential parts of our afni_proc.py (or 3dDeconvolve) options.  First and foremost you have your actual definition of the TENT function, which usually goes something like:

-regress_basis 'TENT(0,12,7)'

Here I’m asking 3dDeconvolve to estimate the response starting at the stimulus onset (0 seconds) and estimate out to 12 seconds.  Since I have a TR of 2 seconds, that means that there are 7 possible TENTs to fit during this time.  When you do this, 3dDeconvolve will generate a Coef and Tstat for EACH and EVERY TENT that you requested.  This isn’t always terribly useful since you may not really care what the “area under the curve” is for say TENT #5 independent of everything else.  Fortunately, you can use the GLT system to get the average over all of these TENTs:

-gltsym 'SYM: +1*conditionA' -glt_label 1 'ConditionA'

Displaying TENTs in AFNI

Once you’ve run an analysis with TENT, you can visualize the TENT at any voxel within the AFNI viewer using the following steps.

1. Open AFNI viewer, set underlay as your anatomical
2. Optionally you can set the overlay to the stats dataset and select your GLT as described above.  This will show you were there is activation according to the model, which may help inform your selection of a voxel to visualize.
3. Open a new AFNI viewer (press the New Button) and make the following selections
   1. Set underlay as the iresp file representing your condition of interest
   2. Click the graph button
4. At this point, moving around on the statistical dataset will show you what the associated response looks like for that particular location.

Other TENT Possibilities

If you want to force your first and last time points in the TENT to be zero, you can use the TENTzero function instead of TENT.  This might be useful.  Ok, it is useful.

Alternatively, if you like the idea of ERPs using peak measures, you might want to contrast the “peak” of your response to the “baseline” or pre-stimulus intervals.  In order to do this, you should tell 3dDeconvolve to use TENT to model some of the time series BEFORE the onset of a stimulus as so:

TENT(-4,12,9)

Here we ask 3dDeconvolve for 4 seconds before the onset of the stimulus and extending to 12 seconds after the stimulus, using 9 TENTs.  In this case, you may not want to use the same GLT you did before, because it would include the pre-stimulus time in the average.  So you can use square-brackets to index one or several TENTs:

-gltsym 'SYM: -1*conditionA[0..2] +1*conditionA[4..6]' -glt_label 1 'conditionA_Peak'

Here we’re subtracting the first 3 TENTS (0, 1, 2) from what I’m calling the “peak” TENTS (4, 5, 6).  Now it’s important to recognize that TENT 0 is -4 seconds, TENT 1 is -2 seconds, TENT 2 is at 0 seconds relative to stimulus onset.  Continuing on TENT 3 is at 2 seconds, TENT 4 is at 4 seconds, TENT 5 is at 6 seconds, and TENT 6 would be at 8 seconds.  So we’re subtracting activations 4 seconds before the stimulus onset from activations 4-8 seconds after.

But how much of a difference does it really make?  Well, of course this is fMRI, so the answer is “it depends”.  If we look at the response curve shown at the top of the article, you might recognize how close it looks to the Gamma function.  If we compare the resulting maps on a basic in-scanner reading experiment, you can see the Gamma shows the most activation; TENTzero over a 12 second window and “TENT Peak” where I pull out the peak (4-8 seconds) and subtract the pre-stimulus interval are fairly close in activation.

I also included the map for the average over both the pre-stimulus and post-stimulus interval to illustrate that you want to be careful NOT to accidentally include the entire window if you have the pre-stimulus baseline included as it may reduce the activations of interest.