To begin with we will prepare data for FAST; this requires running BET for brain extraction. In addition, just for this practical, we will also extract a small ROI containing a few central slices so that FAST only takes a minute to process the data, instead of 10-15 minutes for a full brain.
cd ~/fsl_course_data/seg_struc/fast
Run BET on the input image structural to create
structural_brain (type Bet for the GUI or bet for
the command-line program).
Look at your data
View the output to check that BET has worked
OK (e.g. change the colourmap for structural_brain to say Red-Yellow):
fslview structural structural_brain &
Create a cut-down version (containing a few central slices)
of the brain-extracted image using the region-of-interest program
fslroi . This will let you try out some of the FAST options
without having to wait more than a minute each time.
fslroi structural_brain structural_brain_roi 55 150 15 200 65 5
Open structural_brain_roi in FSLView to see the cut-down image. See how few slices are left.
structural_brain_roi_inhomog which contains the same
section of the same brain but with a different bias field or inhomogeneity (looking a bit more like a surface-coil acquisition).
Add
structural_brain_roi_inhomog to the already open FSLView (or open a new one and load structural_brain_roi first) and then look at the
difference between these images. Note how both grey matter and white matter are darker in the
left anterior portion of the inhomogeneous image.
structural_brain_roi and
structural_brain_roi_inhomog. Use the GUI
(Fast [or Fast_gui on a Mac]) and turn on the "Estimated bias field" button (which saves a copy of the bias field). For
the structural_brain_roi_inhomog case also open the
"Advanced Options" tab and change the "Number of iterations for bias
field removal" to 10 to account for the strong bias field in this
case. Finally, don't forget to check that the output name is
different for the two runs! Once this is set up press "Go" for both -
they should only take a minute to run.
View and compare the two *_seg.nii.gz output segmentations.
Partial Volume Segmentation
Now let's look at the partial volume segmentations. View the
different outputs in FSLView by first loading
structural_brain_roi, then loading the PVE images as
overlays, adjusting the overlay transparency as necessary. Note that you can
tell FSLView what colourmaps and intensity ranges to use from the
command line:
fslview structural_brain_roi structural_brain_roi_pve_0 -l Green -b 0.5,1 \
structural_brain_roi_pve_1 -l Blue-Lightblue -b 0.5,1 \
structural_brain_roi_pve_2 -l Red-Yellow -b 0.5,1 &
Identify which PVE component is the grey matter. Choose a voxel on the border of the grey matter and look at the values contained in the three PVE components. The values represent the volume fractions for the 3 classes (GM, WM, CSF) and should add up to one. Now pick a point in the middle of the grey matter and look at the three values here.
The PVE images are the most sensitive way to calculate the tissue volume which is present. For example, we can find the total GM volume with fslstats by doing:
fslstats structural_brain_roi_pve_1 -m -vThe first number reported by
fslstats gives the mean
voxel GM PVE across the whole image and the third number gives the
total volume of the image (in mm3), so multiplying these
together gives the total GM volume in mm3 (for more details
on fslstats just type fslstats to see its usage description).
Bias Field Correction
Now let's look at the bias field
outputs - structural_brain_roi_bias and
structural_brain_roi_inhomog_bias (these are FAST's
estimates of the bias fields). View these in FSLView and set the
display ranges to be equal for both images (e.g. 0.6 to 1.4). Notice
how much stronger the second one is.
Advanced: Work out how to use fslmaths to compare the estimated bias field between these cases. Create restored images using these bias field estimations and test how well this difference explains the additional bias field (which was artificially added in this case).
cd ~/fsl_course_data/seg_struc/first/
con0047_brain.nii.gz.
Load this into FSLView to start with to see the image.
Note that although this is not normally done, this image has had brain
extraction run on it. This is due to the anonymisation done to the
original image.
To perform the segmentation of the left hippocampus and amygdala we simply need to run one command:
run_first_all -i con0047_brain -b -s L_Hipp,L_Amyg -o con0047 -a con0047_brain_to_std_sub.mat
This command (or script) will run several steps for you and has several options. It will take about 4-5 minutes to run, so while it is running read through the following description.
run_first_all-i specifies the input image (T1-weighted)
-o specifies the output image basename (extensions will be added to this)
-b specifies that the input image has been brain extracted
-s specifies a restricted set of structures to be segmented (just two in this case)
-a specifies the affine registration matrix to standard space (optional)
The run_first_all script uses the best set of parameters
(number of modes, intensity reference) to run for each structure,
as determined by empirical experiments. Therefore it is not necessary
to specify these values when running the method.
Normally the affine registration would be run as part of this script (just leave off the -a option and it will be done automatically), but it has been pre-supplied here in order to save time - as the registration takes about 6 minutes.
We will now go through how this script works and what to look for in the output.
con0047_brain_to_std_sub.nii.gz together with the
1mm standard space template image. Look at the alignment of the
subcortical structures. It should be quite close but we do not expect it to be perfect.
This registration is normally created by run_first_all as
the initial stage, but has been included here from a previous run to
save time. The registration should always be performed using the tools in
FIRST since it does a special registration, optimised for the
sub-cortical structures. It begins with a typical 12 DOF affine
registration using FLIRT, but then refines this in a second stage with
a sub-cortical weighting image that concentrates purely on the
sub-cortical parts of the image. Thus the final registration may not
be as good in the cortex but will better fit the sub-cortical
structures. However, this registration only removes the global affine
component of the differences in the structures and hence will not be
that precise. In addition it, crucially, leaves the relative orientation
(pose) between the structures untouched.
Always make sure you check that the registration has worked before looking at other outputs.
We will now move onto looking
at the other outputs which should have been generated by
run_first_all at this point. If the
run_first_all command has not finished have a quick look
at the FIRST
documentation page.
Before doing anything else we will check the output logs to see if any
errors have occured. Do this with the command:
cat con0047.logs/*.e*
If everything worked well you will see no output from this,
otherwise it will show the errors. If any errors are shown, ask a
tutor about them.
You should always check the error files in the log directories for FIRST and
other FSL commands that create log directories like this (e.g. TBSS, FSL-VBM, BEDPOSTX, etc.).
con0047_brain
and add the image con0047_all_fast_firstseg on top.
This *_firstseg image shows the combined segmentation of all structures based on
the surface meshes that FIRST has fit to the image. It is in the native space of the structural image (not in the standard space, although the registration before was required to move the model from the standard space back into this image's native space).
As converting the underlying
FIRST meshes to a voxel-based image can create overlap at the boundaries, these boundary voxels have been "corrected" or re-classified by run_first_all using
the default method (here it is FAST - which
classifies the boundary voxels according to intensity). Look at the uncorrected segmentations with the following:
fslview con0047_brain con0047_all_fast_origsegs.nii.gz -l Red-Yellow -b 0,118 &
Each structure is labeled with a different intensity value inside and 100 + this value for the boundary voxels (the con0047_all_fast_origsegs image is a 4D image with each structure in a different volume). The intensity values assigned to the interior of each structure is given by the CMA labels.
Have a look at these images to see how good the segmentation is. Play with the transparency settings (or turn the segmentation on and off) to get a feeling for the quality.
This corrected image is normally the one that you would use to define an ROI or mask for a particular subcortical structure. An uncorrected image (showing all the unclassified boundary voxels) is also available -- see the optional practical at the end.
cd ~/fsl_course_data/seg_struc/first/shapeAnalysis
Vertex analysis (or shape analysis) looks at how a structure may differ in shape between two groups (e.g., patients and controls). It looks at the differences directly in the meshes, on a vertex by vertex basis. This is different from using a whole-structure summary measure like volume, as it allows us to visualise the region of the shape that is changing as well as the type of shape change.
first_utils uses a multivariate test to measure
difference in mean vertex location between two groups of subjects.
The test uses Pillai's trace to derive an F-statistic and the output
shows the mean surface displacement vectors between groups as well as
the F-statistic values.
Here we will use an example dataset consisting of 8 subjects (5 controls and 3 Alzheimer's patients) which we will do an analysis on. As the numbers are lower it will have fairly low statistical power, but in this case it still shows a clear effect. A full analysis, on a larger set of subjects, would proceed in exactly the same way.
List the files in this directory - we have already run FIRST on each subject in order to get a segmentation of the left hippocampus. So you will see files such as:
con0047_brain.nii.gz con0047_brain_to_std_sub.mat con0047_brain_to_std_sub.nii.gz con0047.com con0047-L_Hipp_corr.nii.gz con0047-L_Hipp_first.bvars con0047-L_Hipp_first.nii.gz con0047-L_Hipp_first.vtk con0047.logsmost of them should be familiar from the previous example. Because only a single structure was run, the uncorrected segmentation is saved as
con0047-L_Hipp_first and the boundary corrected
segmentation is saved as con0047-L_Hipp_corr (rather than the
names used before in the case of multiple structures).
However, for vertex analysis we will be using the .bvars files
as they contain the information about the sub-voxel mesh coordinates.
In general, to run shape analysis, you need to do the following:
-s
option). We then use the
.bvars files for the vertex analysis.
first_roi_slicesdir, which shows an ROI (with 10 voxel padding) around the structure of interest for each subject, summarised into a single webpage. In this case run:
first_roi_slicesdir *brain.nii.gz *L_Hipp_first.nii.gzand then view the output
index.html in a web browser (it will be created in a
subdirectory called slicesdir/). Check that none of the
segmentations have failed; make sure that you look at the axial,
coronal and sagittal slices.
.bvars file)
into a single file. Each structure (model) that is fit with FIRST will
generate a separate .bvars file. For a given structure
(e.g. hippocampus) combine all the relevant .bvars files
using the concat_bvars script. For this
example, you need to combine the .bvars files (all of the left
hippocampi) using the command:
concat_bvars all.bvars *L_Hipp*.bvars
.bvars were combined in the concat_bvars call. The design
matrix can be created using FSL's Glm tool (a single
column in this case). For now the design matrix
(design_con0_dis1.mat) has been provided for you in the current
directory, just for this example. This is the same kind of
design matrix used with the GLM in FEAT (see the FEAT lectures if
you are unfamiliar with this). It contains a list of 0's and 1's that represent the two different groups. Within the vertex analysis this will be demeaned, along with the shape data.
We are now ready to run first_utils and perform the vertex analysis.
We will do the analysis using --useReconMNI to
reconstruct the surfaces in MNI152 space (though note that an
alternative would be to reconstruct the surfaces in the native space
using --useReconNative).
Perform the vertex analysis using the command:
first_utils --usebvars --vertexAnalysis -i all.bvars -o diff_con0_dis1_L_Hipp_mni -d design_con0_dis1.mat --useReconMNI
If you are running the above command on a personal install of FSL, it may fail unless FSL is installed at /usr/local/fsl .
Now we will load the output of the vertex analysis, diff_con0_dis1_L_Hipp_mni1.vtk,
into the 3D viewer in FSLView and see the vectors on the surface that depict the displacement between group means.
Start fslview and press File -> Open standard; select the
MNI152 nonlinear brain (MNI152_T1_1mm_brain). Start the 3D rendering
tool (Tools -> 3D Viewer). For ease of visualization, turn off the main surface by
double-clicking on MNI152_T1_1mm_brain in the image layer list at the
bottom. Now add the surface using the surface add button [3] and
select the file diff_con0_dis1_L_Hipp_mni1.vtk.
Note that the colour coding shown describes the F-statistic for a given vertex (with red for low F-values and blue for high F-values).
Now open the mesh options menu[4].
You will have to open a separate FSLView for each file in order to interact with them properly.
Some notes for running vertex analysis in practice
.bvars files output by FIRST and a design matrix. These contain all the information required by first_utils.
--useReconMNI, use the --useReconNative and --useRigidAlign options.
--useRigidAlign flag, first_utils will align each surface to the mean shape (from the model
used by FIRST) with 6 degrees of freedom (translation and rotation). The transformation is calculated such that the sum-of-squared distances between the
corresponding vertices is minimized. This command is needed when using --useReconNative, however, can be used with --useReconMNI to remove local
rigid body differences.
--useScale flag can be used in combination with --useRigidAlign to align the surfaces using 7 dof. --useScale
will indicate to first_utils to remove global scaling.
cd ~/fsl_course_data/seg_struc/siena ls
The example data is two time points, 24 months apart, from a subject with probable Alzheimer's disease. The command that was used to create the example analysis is (don't run this - it takes too long!):
siena sub3m0 sub3m24 -d -m -b -30The -d flag tells the siena script not to clean up the many intermediate images it creates - you would not normally use this. The other options are explained later.
SIENA has already been run for you. Change directory into the SIENA output directory:
cd sub3m0_to_sub3m24_siena lsIn the SIENA output directory the first timepoint image is named "A" and the second "B", to keep filenames simple and short. To view the output report, open
report.html in a web browser. The
next few sections take you through the different parts of the webpage
report, which correspond to the different stages of the SIENA
analysis.
First BET was run on the two input images, with options telling it to create the skull surface image and the binary mask image, as well as the default brain image.
Other BET options can be included in the call to siena by adding
-B "betopts" - for example -B "-f 0.3"
on the siena command line tells siena to pass on the -f
0.3 option to BET, which causes the estimated brain to be
larger if the value used is less than 0.5, and smaller otherwise.
You also might need to use the -c option to BET if you
need to tell BET where to center the initial brain surface, such as
when you have a huge amount of neck in the image. For example, if it
looks like the centre of the brain is at 112,110,78 (in voxels,
e.g. as viewed in FSLView), and you want to combine this option with
the above -f option, you would add, to the siena command,
-B "-f 0.3 -c 112 110 78"
You can see the two brain and skull extractions in the webpage report. If you want to see these in more detail, open the relevant images in FSLView, for example:
fslview A A_brain -l Red-Yellow A_brain_skull -l Green
Be aware that the skull estimate is usually very noisy but that it is only used to determine the overall scaling and this process is not very sensitive to the noise as long as the majority of points lay on the skull.
Now the two time points are registered using the script siena_flirt. This runs the 3-step registration (brains, then skulls, then brains again). The transformation is "halved" so that each image can be transformed into the space halfway between the two. The webpage report shows the alignment of the two brains in this halfway space. You need to check that the two timepoints are fundamentally well-aligned, with only small (e.g. atrophy) changes between them. Look out for mistakes such as: the two images coming from different subjects, one image being left-right flipped relative to the other one, or one image having bad artefacts.
If you want to look at the registration in more detail:
fslview A_halfwayto_B_brain B_halfwayto_A_brain
Now, if standard-space-based masking has been requested (it was in this case), the two brain images are registered to the standard brain ${FSLDIR}/data/standard/MNI152_T1_2mm_brain using FLIRT. The transforms (and their inverses) are saved. The two brains are registered separately and their transforms compared to test for consistency.
The webpage report shows the two images transformed into standard space, with the overlaying red lines derived from the edges of the standard space template, for comparison.
If the -m option was set, a standard space brain mask is now transformed into the native image space and applied to the original brain masks produced by BET. This is in most areas a fairly liberal (dilated) brain mask, except around the eyes.
If the -t or -b options are set then an upper or lower limit (in the Z direction) in standard space is defined, to supplement the masking. This is useful, for example, to restrict the field-of-view of the analysis if you have variable field-of-view at the top or bottom of the head in different subjects.
The webpage report shows the -m brain masking in blue, the -t/-b masking in red (you can see the effect of the -b -30 option), and the intersection of the two maskings in green. It is this intersection that is what gets finally used.
The final step is to carry out change analysis on the registered masked brain images. At all points which are reported as boundaries between brain and non-brain, the distance that the brain surface has moved between the two time points is estimated. The mean perpendicular surface motion is computed and converted to PBVC (percentage brain volume change).
The webpage report shows the edge motion colour coded at the brain edge points, and then shows the final global PBVC value. To see the edge motion image in more detail:
fslview A_halfwayto_B_render
We now look at 4 examples of "problem cases" - these were real
cases that occurred in one study; they illustrate some of the
problems/mistakes that sometimes occur.
cd ~/fsl_course_data/seg_struc/siena_problems/eg1/S2_032_ax_to_S2_164_ax_siena
Open report.html in a web browser.
Look at the FLIRT A-to-B registration results. Can you tell
what's wrong? If you're unsure, click here.
cd ~/fsl_course_data/seg_struc/siena_problems/eg2/S2_039_ax_to_S2_142r_ax_siena
Open report.html in a web browser.
Look at the FLIRT A-to-B registration results. Can you tell
what's wrong? If you're unsure, click here.
cd ~/fsl_course_data/seg_struc/siena_problems/eg3/S2_080_ax_to_S2_121_ax_siena
Open report.html in a web browser.
Look at the FLIRT A-to-B registration results. Can you tell
what's wrong? If you're unsure, click here.
cd ~/fsl_course_data/seg_struc/siena_problems/eg4/S2_002_ax_to_S2_162_ax_siena
Open report.html in a web browser.
Look at the FLIRT A-to-B registration results. Can you tell what's wrong? If you're unsure, click here.
In this section we look at a small study comparing patients and controls for focal differences in grey matter density, using FSL-VBM. Most of the steps have already been carried out, as there isn't enough time in this practical to run all of the registrations required to carry out a full analysis from scratch.
cd ~/fsl_course_data/seg_struc/vbm
Do an ls in the directory. Note that we have renamed the image files with some prefixes so that all controls and patients would be organised in "blocks". This is to make the statistical design easily match the alphabetical order of the image files (who will be later concatenated to be statistically analysed).
We have 10 controls and 8 patients and wish to carry out just a
control>patient comparison. First, we need to define the statistical design, which will be here a simple two-tailed t-test to compare both groups. For this, use the Glm gui to
generate simple design.mat and design.con files, using the higher-level/non-timeseries tab in the GLM setup window. At this point, you need to enter the appropriate overall number of subjects as inputs in the GLM setup window (here n=18, then press enter), and then use the wizard button of the GLM setup window with the "two groups, unpaired option" and appropriate number of subjects for the first group (here ncontrols=10). If the design looks correct, then save it by pressing "save" in the GLM setup window and give it the output basename of "design". In this analysis, only the design.mat and design.con files will be used.
Moreover, as we have more controls than patients, you will need to list the subjects used for the creation of the study-specific template by missing out the last
2 controls for instance (con_3699.nii.gz and con_4098.nii.gz), so that the number of controls used to build this
study-specific template matches the number of patients
in the template_list text file:
for g in con_1623.nii.gz con_2304.nii.gz con_2878.nii.gz con_3456.nii.gz con_3641.nii.gz con_3642.nii.gz \ con_3668.nii.gz con_3670.nii.gz pat_1433.nii.gz pat_1650.nii.gz pat_1767.nii.gz pat_2042.nii.gz pat_2280.nii.gz \ pat_2632.nii.gz pat_2662.nii.gz pat_2996.nii.gz; do echo $g >> template_list done
Preprocessing
We first ran the initial FSL-VBM script, fslvbm_1_bet. This moved all the original files into the
origdata folder; to see what they all look like, view the
following in a web browser:
origdata/slicesdir/index.html. This has also created some brain-extracted images. We actually
ran fslvbm_1_bet both with the 'default' -b option and then,
because the original images have a lot of neck in them, which was
often being left in by the default brain extractions, we ran using the
-N option. Compare the different results from the two
options by loading in the two web pages:
struc/slicesdir-b/index.html
and
struc/slicesdir-N/index.html
It is very obvious which option is working well and which one isn't!
Next all the brain images are segmented into the different tissue types, and then the study-specific GM template is created, by registering all GM segmentations to standard space, and averaging them together. The command used was:
(don't run this!) fslvbm_2_template -n
You can view all of the alignments to the MNI152 initial standard space
by running the following, and turning on FSLView movie mode:
fslview struc/template_4D_GM
and then view the alignment of the study-specific template to the
MNI152 standard space with:
fslview ${FSLDIR}/data/standard/MNI152_T1_2mm struc/template_GM -l Blue-Lightblue -b 0.2,1 &
Finally, the registrations to the new, study-specific, template
were run for all subjects, and modulated by the warp field expansion
(Jacobian), before being combined across subjects into the 4D image
stats/GM_mod_merg. An initial GLM model-fit is run in
order to allow you to view the raw tstat images at a range of
potential smoothings. This was achieved by running:
(don't run this!) fslvbm_3_proc
So now you can have a look at the initial raw tstat images created at the different smoothing levels, pick the one you "like" best.
cd stats
fslview template_GM -b .1,1 GM_mod_merg_s4_tstat1 -b 2.3,6 \
GM_mod_merg_s3_tstat1 -b 2.3,6 GM_mod_merg_s2_tstat1 -b 2.3,6 &
The different images that you can see in the stats
directory are:
GM_mask - the result of thresholding the mean (across
subjects) aligned GM image at 1% and turning into a binary mask.
GM_merg - a 4D image containing all subjects' aligned
GM images.
GM_mod_merg - the same as above, but after the GM
densities have been "modulated by the warp field Jacobian" (adjusted
for warp expansion/contraction).
GM_mod_merg_s2 / 3 / 4 - the same as above, but after
Gaussian smoothing of 2, 3 and 4mm FWHM.
GM_mod_merg_s2_tstat1 / s3 / s4 - the raw t-statistic
images from feeding the smoothed datasets into a GLM via randomise.
design.mat / design.con - the design matrix and
contrast file specifying the cross-subject model that is fit to the
data by randomise.
template_GM - the study-specific GM template that was
derived as part of the FSL-VBM analyses, and to which all subjects' GM
images were finally aligned to.
You are now ready to carry out the cross-subject statistics. We
will use randomise for this, as the above steps are very
unlikely to generate nice Gaussian distributions in the data.
Normally we would run at least 5000 permutations (to end up with
accurate p-values), but this takes a few hours to run, so we will
limit the number to 100 (to get a quick-and-dirty result). We will
also use TFCE thresholding (Threshold-Free Cluster Enhancement - this
is explained in the randomise lecture) which is similar to
cluster-based thresholding but generally more robust and sensitive.
For example, if you decide that the appropriate amount of smoothing
is a HWHM of 3mm, then the following will run
randomise with TFCE and a reduced number of 100 iterations:
randomise -i GM_mod_merg_s3 -o tmp -m GM_mask -d design.mat -t design.con -n 100 -T -V fslview template_GM -b .1,1 tmp_tfce_corrp_tstat1 -l Red-Yellow -b 0.8,1
In this example we set the corrected p-threshold to 0.2 (i.e. 0.8 in FSLView), because of the reduced numbers of subjects in this example and hence low sensitivity to effect - you would not be allowed to get away with this in reality!
cd ~/fsl_course_data/seg_struc/fast
In sub2_t1 and sub2_t2 are T1-weighted and T2-weighted
images of the same subject. Are they well aligned? You can get an easy
non-interactive combined view of two images (which must have the same
image dimensions) with slices:
slices sub2_t1 sub2_t2
They look reasonably aligned in sagittal and coronal view, but axial views clearly show misalignment between scans. Before running multi-channel FAST it is necessary to use FLIRT to register the data. Start by running BET on each image to remove the non-brain structures. Then start the FLIRT GUI:
Flirt_gui &
For example, set sub2_t1_brain as the
Reference image and set sub2_t2_brain as the
Input image. Set the Output image to something like
sub2_t2_to_t1 and the DOF to 6.
All the other FLIRT defaults should be fine, but
you could save some processing time by telling FLIRT that the images
are Already virtually aligned (in
Advanced->Search->Images). FLIRT will take a minute or two to
run.
Load sub2_t1_brain and sub2_t2_to_t1 into FSLView to
check the result of the registration. Make the higher image in the
list show as Red-Yellow and increase its transparency so that you can
see how good the overlap is.
You can now forget sub2_t2.
Run FAST (with the Number of input channels set to 2) on the
multi-channel brain-extracted images sub2_t1_brain and
sub2_t2_to_t1_brain (or whatever you called these BET
outputs). Asking for the default number of classes (3 - assumed to be
GM/WM/CSF) gives poor results because bits of other tissues outside of
the brain are given a class - so you should run with 4 classes; then
results should be good. This takes a few minutes; move on to the next
part of the practical and view the results once fast has finished
running.
fast -hYou could also work out how to colour-overlay segmentation results onto the input image using overlay.
cd ~/fsl_course_data/seg_struc/first
This follows on from the initial part of the FIRST practical above
and assumes that run_first_all has been successfully run.
Having considered the boundary corrected segmentation previously, we
now turn to look at the uncorrected segmentation.
The uncorrected segmentation shows two types of voxels: ones that the
underlying surface mesh passes through (boundary voxels) and ones that
are completely inside the surface mesh (interior voxels). FIRST uses a
mesh to model the structure when doing the segmentation, so converting
this to a volume requires it to be split into boundary and interior
regions like this. We will use the mesh outputs (the
*.vtk files) later to do vertex analysis, which utilises the
sub-voxel precision.
We will now look at the uncorrected volumetric segmentations:
fslview con0047_brain con0047_all_fast_origsegs
To view the segmentation better change the colourmap of the segmented image to "Red-Yellow" and make the "Max" display range value to 100 for this image. Note that you see the interior voxels and the boundary voxels in different colours. This is because the boundary voxels are labeled with a value equal to 100 plus that of the interior voxels. That is, the interior and boundary voxels for the left hippocampus are labeled 17 (the CMA label designation for left hippocampus) and 117 respectively.
The volume con0047_all_fast_origsegs is a 4D file
containing each structure's segmentation in a separate 3D file.
If you change the "Volume" control on FSLView to go from 0 to 1
then you will see the left amygdala result. These are separated
in case these uncorrected segmentations overlap. Play with the
transparency settings (or turn the segmentation on and off) to see
how good the segmentation is.
These images require boundary correction which is done
automatically by run_first_all. However, there are
alternative methods for doing the boundary correction which you can
specify with run_first_all or as a post-processing on the
uncorrected image with first_boundary_corr, although the
settings used by run_first_all have been chosen as the
optimal ones based on empirical testing.
cd ~/fsl_course_data/seg_struc/siena/sub3m0_sienax
In this section we look at how SIENAX works and look at the most useful outputs.
Open report.html in a web browser. The example data is
one time point from a subject with probable Alzheimer's disease. The
command that was used to create the example analysis is (don't run
this!):
sienax sub3m0 -d -b -30 -r
SIENAX starts by running BET and FLIRT in a manner very similar to SIENA, except that the second time point image is replaced by standard space brain and skull images. Next a standard space brain mask is always used to supplement the BET segmentation.
As before, optional Z limits in Talairach/standard space can be used to mask further.
Next, FAST is used, with partial volume estimation turned on, to provide an accurate estimate of grey and white matter volumes. In order to provide normalised volumes for GM/WM/total, the volumetric scaling factor derived from the registration to standard space is used to multiply the native volumes; the values are thus normalised for head size. Interesting output images are (view with fslview):
I_stdmaskbrain - fully masked brain image - the input to FAST segmentation. (Note where standard-space-based masking has cutoff the bottom of the brain.)
I_render - the segmentation output colour-overlaid onto
the input.
(If you zoom in you'll see that the colour overlay is
shown in checkerboard pattern - this is an option in the
overlay program, to make the overlay appear more transparent,
for clarity.)
I_stdmaskbrain_pve_0 (etc) - the partial volume segmentation outputs.
Because we used the -r option, we also have two extra regional measurements. Use fslview to view I_vent_render; here the CSF PVE image has been masked by a standard-space (dilated) ventricle mask, to enable SIENAX to estimate ventricular CSF (the colouring is a little hard to see as it was rendered transparently). Now view I_periph_render; here the GM PVE image has been masked by a standard-space cortex mask to try to remove cerebellum, brain stem, ventricles and deep grey - it's not perfect but it's not bad....
In the final example we take the output of SIENA, run on data from 13 controls and 13 patients, each having been scanned twice, with an interval of a year. We will run voxelwise analysis, to attempt to localise where there is a difference in atrophy between the two groups.
We have already run siena on all 26 subjects, and have also run the
script which transforms the edge-motion image created by siena into
standard space. This involved simply running(don't run
this!) siena_flow2std A
B -s 10
for each subject, where A and B
are the two timepoint image names. This takes the edge motion image
generated by siena, dilates this several times (to
"thicken" this edge flow image), transforms to standard space, and
masks with a standard space edge mask. It then smooths this with a
Gaussian filter of half-width 10mm before remasking.
All subjects now have an edge flow image in standard edge space
called A_to_B_flow_to_std. These have been merged (across
all subjects) into a single 4D image flow2std4D, which
you can find:
cd ~/fsl_course_data/seg_struc/sienar
(you may need to adjust the intensity
display range to be small....say -0.2:0.2)
fslview flow2std4D
Have a quick look; turn on movie mode to flick through all the timepoints. The control subjects comprise the first 13 timepoints, followed by the 13 patients.
You are now ready to carry out the cross-subject statistics. We will use randomise for this, as the above steps are very unlikely to generate nice Gaussian distributions in the data.
First you will need to generate a FEAT-style design matrix
design.mat and contrasts file
design.con. Start the Glm GUI:
Glm_gui &
Change Timeseries design to Higher-level /
non-timeseries design. Change the number of inputs to 26 (press
Return after typing the number) and then use the wizard
to setup the two-group unpaired t-test (13 subjects in each
group). Finally, save the design as filename design, and
in the terminal use more to look at the
design.mat and design.con files.
Now you can run randomise. The mask image is the
standard space MNI152 brain edge mask image supplied with FSL. You
would normally run at least 5000 permutations (to end up with accurate
p-values), but this takes a few hours to run, so we will limit the
number to 100. We will also use TFCE thresholding (Threshold-Free
Cluster Enhancement - this is explained in the randomise lecture)
which is similar to cluster-based thresholding but generally more
robust and sensitive. To use TFCE on this "surface" data, use the
--T2 option in randomise. To run randomise,
type:
randomise -i flow2std4D -o sienar -m ${FSLDIR}/data/standard/MNI152_T1_2mm_edges -d design.mat \
-t design.con -n 100 -V --T2
Now you can load the outputs into FSLView:
fslview ${FSLDIR}/data/standard/MNI152_T1_2mm sienar_tstat1 -l Red-Yellow -b .5,3 \
sienar_tstat2 -l Blue-Lightblue -b .5,3 sienar_tfce_corrp_tstat1 -l Green -b 0.949,1 \
sienar_tfce_corrp_tstat2 -l Copper -b 0.949,1
Make sure that you understand the different parts of this call to
fslview, and what each image is showing - turn all the stats overlays
off and turn on one at a time to make it easy to work out what's going
on. sienar_tstat1 shows the raw (unthresholded) tstat for
contrast 1. sienar_tfce_corrp_tstat1 shows the corrected
p-values for contrast 1 (actually, it shows 1-p, for convenience of
display, hence the thresholding chosen, which corresponds to p<0.05,
corrected for multiple comparisons across space).
How can you disambiguate what's going on where there is a group difference? For example, if the control>patient test (tstat1) shows a positive value, is this because the control group had "growth", the patient group had atrophy, or both? You can answer this by loading in the raw tstat images for the separate group-mean contrasts (3 and 4) - this lets you look to see what each group is doing separately.