PTBP_Intro.Rmd

---
title: 'The Pediatric Template of Brain Perfusion: Quick introduction with *ANTsR*'
author: "Brian B. Avants et al."
date: '`r Sys.Date()`'
output:
  slidy_presentation:
    highlight: tango
    incremental: yes
  ioslides_presentation:
    highlight: tango
    incremental: yes
  beamer_presentation:
    colortheme: dolphin
    fonttheme: structurebold
    highlight: tango
    includes:
      in_header: mystyle.tex
    incremental: yes
    theme: AnnArbor
    toc: yes
---

```{r setup,eval=TRUE,results='hide',warning=FALSE,echo=FALSE}
# set this for your own compilation
bd = path.expand( "~/" )
```

# Overview and resources

## Overview

This is a compilable document with source code located here:

[https://github.com/stnava/ANTsTutorial](https://github.com/stnava/ANTsTutorial)

To get this source, do:

```bash
git clone http://github.com/stnava/ANTsTutorial.git
```
It is expected that you will compile and run this from within
the cloned `ANTsTutorial` directory.  The document needs the [ants tutorial data](https://www.dropbox.com/s/5p0vlx8en9uzbge/ants_tutorial_data.zip?dl=0)
discussed below. It depends on *R*, *rmarkdown* and *ANTsR* primarily.

Herein, [links are in this color](http://lmgtfy.com).

## Overview

The Pediatric Template of Brain Perfusion (PTBP) [at figshare](http://figshare.com/articles/The_Pediatric_Template_of_Brain_Perfusion_PTBP_/923555).

- Free multiple modality MRI data with demographics and psychometrics
- Collected to aid as a reference for normal variability in structure and cerebral blood flow during adolescence
- The data is accompanied by an [organized csv file](http://files.figshare.com/1699436/ptbp_summary_demographics.csv)
- The full data is available at [figshare](http://figshare.com/articles/The_Pediatric_Template_of_Brain_Perfusion_PTBP_/923555)
- Here we use a slightly processed version of the data
- Each subject contains a slab version of T1, FA, B0, CBF, Thickness, Segmentation and AAL in subject space
- There is also a template contained in the download.

## Download the ANTs tutorial data

\Large

- Download
- <https://www.dropbox.com/s/5p0vlx8en9uzbge/ants_tutorial_data.zip?dl=1>
- Move this to your ANTsTutorial directory.
- Unzip the file in the ANTsTutorial directory.

## The tutorial PTBP data

- This is a subset of the full PTBP dataset.
- This data has been affinely registered to the template and subsetted with a slab ROI.
- Allows us to speed up examples but still show high-res results.
- Each modality for each subject is in his/her T1 anatomical space.
- An additional deformable mapping is needed to transform this subject space to template space or vice-versa.


## A complete reference for PTBP processing

```bash
git clone http://github.com/jeffduda/NeuroBattery.git
```

This will give you both raw and processed output
for a single multiple modality subject.

We test (occasionally) against this reference output to monitor
stability of our processing.


## If you have not already, download [*ANTsR*](http://stnava.github.io/ANTsR/)

* Get *R* from [OSX *R*](http://cran.r-project.org/bin/macosx/) or
  [Linux *R*](http://www.jason-french.com/blog/2013/03/11/installing-r-in-linux/),
  optionally [*RStudio*](http://www.rstudio.com/products/rstudio/download/)
* Install *ANTsR* dependencies
```r
pkgmin=c("magrittr","Rcpp") # core dependencies
pkgxtra=c("igraph","randomForest","misc3d","rgl",
  "mFilter","fastICA","fpc","knitr","rmarkdown",
  "pixmap","png","signal","visreg")
install.packages( c( pkgmin, pkgxtra ) )
```
* Download the *ANTsR* tar.gz to `filename.tar.gz`
* Install via command line (or *RStudio* `tools` $\rightarrow$ `install`):
```bash
   R CMD INSTALL filename.tar.gz
```

## Test [*ANTsR*](http://stnava.github.io/ANTsR/)

* Test via ( in `R` ) calling:
```r
  library(ANTsR)
  ?antsRegistration
```
* then run the example (successfully?)
* just to be sure, run some of the vignettes 
* ... (break here?)
* Done!

# Quick Look

## Get the demographics file

```{r csv}
library(ANTsR)
csvlink="https://ndownloader.figshare.com/files/1699436"
tfn=tempfile(fileext='.csv')
if ( ! exists("demog") )
  {
  demog=download.file(csvlink,tfn)
  if ( demog == 0 ) demog=read.csv( tfn )
  }
```

## Investigate the demographics

```{r demog}
str(demog[,1:10])
```

## Investigate the demographics

```{r demog2}
str(demog[,11:20])
```

# Review multiple modality images

## Read the structural PTBP template image

```{r readstruct, echo=TRUE}
if ( ! exists( "ch2" ) )
  ch2 = antsImageRead( getANTsRData("ch2"))
t1fn = paste(bd,
  "data/antsExamples/ANTsTutorial/data/template/PTBP_T1_BrainCerebellum.nii.gz",
  sep='')
t1tem = antsImageRead( t1fn )
```

## Plot the structural PTBP template image

```{r plotstruct, echo=FALSE, warning=FALSE}
plot( t1tem, slices=10 )
# plot( t1tem, axis=3, slices=82, domainImageMap=ch2 )
```

## Plot the CBF PTBP template image

```{r plotcbf, echo=FALSE, warning=FALSE}
cbftem = paste(bd,"data/antsExamples/ANTsTutorial/data/template/PTBP_CBF.nii.gz",sep='')
cbftem = antsImageRead( cbftem )
plot(cbftem,dorot=1,slices=10)
```

## Find subject image

```{r substruct, echo=TRUE}
subnum=11
id=demog$SubID[subnum]
dt=demog$ScanDate[subnum]
exts=c( "mprage_t1.nii.gz" ,
        "fa_anatomical.nii.gz",
        "MeanCBFWarpedToT1.nii.gz",
        "CorticalThickness.nii.gz",
        "BrainSegmentation.nii.gz",
        "AAL.nii.gz" )
pre=paste( bd,"data/antsExamples/ANTsTutorial/data/Subjects/",id,"/",dt,"/*",sep='')
fns=Sys.glob( paste( pre, exts , sep='') )
```

## Review each modality
```{r mod1, echo=FALSE}
plot( antsImageRead( fns[1] ), dorot=1, slices=10)
```

## Review each modality
```{r mod2, echo=FALSE}
plot( antsImageRead( fns[2] ), dorot=1, slices=10)
```

## Review each modality
```{r mod3, echo=FALSE}
plot( antsImageRead( fns[3] ), dorot=1, slices=10)
```

## Review each modality
```{r mod4, echo=FALSE}
plot( antsImageRead( fns[4] ), dorot=1, slices=10)
```

## Review each modality
```{r mod5, echo=FALSE}
plot( antsImageRead( fns[5] ), dorot=1, slices=10)
```

## Review each modality
```{r mod5b, echo=FALSE}
cseg=antsImageRead( fns[5] ) %>% thresholdImage(2,2)
plot( antsImageRead( fns[1] ), cseg, dorot=1, slices=10)
```

## Review each modality
```{r mod6, echo=FALSE}
aal=antsImageRead( fns[6] )
plot( antsImageRead( fns[1] ), aal, dorot=1, slices=10,
      window.overlay=c( 1, max(aal) ) )
```

## Review each modality
```{r mod1b, echo=FALSE}
fa=( antsImageRead( fns[2] ) %>% iMath("Normalize") ) * 255
fa=iMath(fa,"Canny",1,5,12)
plot( antsImageRead( fns[1] ), fa, dorot=1, window.overlay=c(0.5,1),slices=10 )
```

## Count complete subject images

```{r ctsubimages, echo=TRUE}
havecompletesubject=rep(FALSE,nrow(demog))
for ( x in 1:nrow(demog) )
  {
  id = demog$SubID[x]
  dt = demog$ScanDate[x]
  pre = paste( bd,"data/antsExamples/ANTsTutorial/data/Subjects/",
               id,"/",dt,"/*",sep='')
  fns = Sys.glob( paste( pre, exts , sep='') )
  if ( length( fns ) == 6 ) havecompletesubject[x]=TRUE
  }
nsub=sum( havecompletesubject  )
```

## PTBP in our tutorial

We have `r nsub` multiple modality subjects to process
and to analyze.

We will use them to:

* Build a template with priors via [joint label fusion](http://www.ncbi.nlm.nih.gov/pubmed/22732662)

* Normalize, segment, compute thickness

* Map other modalities to structural reference

* Investigate [Eigenanatomy](https://scholar.google.com/scholar?hl=en&q=Eigenanatomy&btnG=&as_sdt=1%2C5&as_sdtp=) and [SCCAN](https://scholar.google.com/scholar?q=sparse+canonical+correlation+avants&btnG=&hl=en&as_sdt=0%2C5) for relating demographic and psychometric measurements to the imaging and ...

* relating imaging modalities to each other.

* Finally, put all this together to create a reproducible analysis document for the PTBP.


# Templates and joint label fusion

## We built a template, now what?

* Suppose a dataset that already contains segmentations.

* Transform these segmentations to the template.

* Perform a weighted voting to customize the segmentations for the template.

## Template priors with SyN-Quick

```{r maptem, echo=TRUE, eval=FALSE, warning=FALSE}
# t1tem read before
ilist=list()
seglist=list()
for ( x in which( havecompletesubject ) )
  {
  id = demog$SubID[x]
  dt = demog$ScanDate[x]
  pre = paste( bd,"data/antsExamples/ANTsTutorial/data/Subjects/",
               id,"/",dt,"/*",sep='')
  fns = Sys.glob( paste( pre, exts , sep='') )
  t1 = antsImageRead( fns[1] )
  mytx = antsRegistration( t1tem, t1, "SyN" )
  seg = antsImageRead( fns[5] )
  segw = antsApplyTransforms( t1tem, seg, mytx$fwd, 
                              interpolator="NearestNeighbor"  )
  ilist = lappend( ilist, mytx$warpedmovout )
  seglist = lappend( seglist, segw )
  }
```

## Template, intensity images, segmentations $\rightarrow$ JLF

* Joint label fusion is a multi-atlas segmentation method.

* It performed well in several recent competitions ([SATA 2012, SATA 2013](http://www.ncbi.nlm.nih.gov/pmc/articles/PMC3837555/))

* We use it regularly in our studies to build template priors and to label cortical or deep structures in the brain.

## JLF theory: "Multi-Atlas Segmentation with Joint Label Fusion"

A matrix $M_x$ is defined by the number of atlas segmentations one has.

$M_x(i,j)$ measures joint atlas errors wrt a target segmentation at a voxel.

Entries in $M_x$ relate to the likelihood two atlases make the same error.

> The key difference between joint label fusion and other label fusion methods is that it explicitly considers correlations among atlases, i.e., the dependence matrix, into voting weight assignment to reduce bias in the atlas set.

## JLF theory: "Multi-Atlas Segmentation with Joint Label Fusion"

The expected label difference between the consensus solution obtained from weighted voting and the target segmentation is: $w_x^T M_x w_x$.

Find atlas weights, $w_x$, for each of $A^i$ atlases, st
$$ w_x^T ( M_x + \alpha \text{Id} ) w_x $$
is minimized subject to $\sum_{i=1}^n w_x(i)=1$.

## JLF theory: "Multi-Atlas Segmentation with Joint Label Fusion"

Define
$$ K_m = \langle |~A^{i,m}_N - T^{m}_N~|, |~A^{j,m}_N - T^{m}_N~| \rangle $$
then
$$ M_x(i,j) =  ( \sum_m K_m )^\beta $$
with $N$ representing a neighborhood calculation, $A^{i,m}$ representing the $i^\text{th}$ atlas and the $m^\text{th}$ modality. Lagrange multipliers yield:
$$w_x=\frac{M_x^{-1} 1_n}{1_n^t M_x^{-1} 1_n}$$

Finally, local patch search is used to improve the neighborhoods that correspond.

## JLF Example

Suppose that a pair of atlases $A_1$ and $A_2$ produce statistically independent label errors for a given target image. If $A_1$ produces a wrong label 50\% of the time and $A_2$ produces a wrong label 20\% of the time, we have
$$
M_x = \begin{bmatrix}
    0.5       & 0.1 \\
    0.1       & 0.2
\end{bmatrix}
$$
The optimal voting weights are then $w_x = [0.2, 0.8]^t.$

## Template [Joint Label/Intensity Fusion](http://journal.frontiersin.org/article/10.3389/fninf.2013.00027/abstract)

```{r jlftem, echo=TRUE, eval=FALSE, warning=FALSE }
if ( !exists("ilist") )
  ilist=imageFileNames2ImageList(
    Sys.glob( paste(bd,"data/antsExamples/ANTsTutorial/data/JLF/ilist*.nii.gz",sep='')) )
if ( !exists("seglist") )
  seglist=imageFileNames2ImageList(
    Sys.glob( paste(bd,"data/antsExamples/ANTsTutorial/data/JLF/slist*.nii.gz",sep='')) )
mk=getMask(t1tem)
jlf=jointIntensityFusion( t1tem, mk, ilist,
  labelList=seglist, rad=rep(3,3), rSearch=2,
  computeProbs=TRUE, nonnegative=TRUE )
# write out results
if ( ! exists("tf") ) tf=tempfile()
antsImageWrite( jlf$segimg, paste(tf,'seg.nii.gz',sep='') )
antsImageWrite( jlf$predimg, paste(tf,'pred.nii.gz',sep='') )
for ( i in 1:length(jlf$probimgs) )
  antsImageWrite( jlf$probimgs[[i]],
                  paste(tf,'prob',i,'.nii.gz',sep='') )
```

## Augment CSF probability

* Standard JLF doesnt capture CSF very well.  

* Let's fix that.

```{r temper,eval=TRUE,results='hide',warning=FALSE,echo=FALSE}
if ( ! exists("jlf") ) {
tf=paste(bd,"data/antsExamples/ANTsTutorial/data/JLF_out/jlfout_",sep='')
kk=Sys.glob( paste(tf,"prob*nii.gz",sep='') )
segfn=paste( tf,"seg.nii.gz", sep='')
jlf=list( segimg=antsImageRead(segfn),
  probimgs=imageFileNames2ImageList( kk  ) )
}
```

```{r kmeanstemplate1,eval=TRUE}
if ( !exists("mk") ) mk=getMask(t1tem)
ktem=kmeansSegmentation(t1tem,3,mk)
jlcsf=jlf$probimgs[[1]][ mk==1 ]
kmcsf=ktem$probabilityimages[[1]][ mk==1 ]
csfmat=rbind( jlcsf, kmcsf )
newcsfvec = apply( csfmat, MARGIN=2, FUN=max )
newcsf=makeImage( mk, newcsfvec )
```

## Augment CSF probability

```{r kmeanstemplate2,eval=TRUE}
plot( jlf$probimgs[[1]],dorot=1,window.img=c(0,4), slices=10 )
```

## Augment CSF probability

```{r kmeanstemplate3,eval=TRUE}
plot( newcsf,dorot=1,window.img=c(0,4), slices=10 )
```


## Renormalize probabilities

```{r renoprobs,eval=TRUE}
csfind=1
ncsf=2:length(jlf$probimgs)
jlfmat=imageListToMatrix( jlf$probimgs, mk )
prsums=colSums( jlfmat ) # i=26 for testing
for ( i in 1:ncol(jlfmat) ) {
  colvec=jlfmat[,i]
  ncsfsum=sum( colvec[ncsf] )
  csfval=newcsfvec[i]
  colvec[csfind]=csfval # the fix is in!
  if ( ncsfsum > 0 )
    colvec[ncsf]=colvec[ncsf]/ncsfsum*(1.0-csfval)
  else colvec[csfind]=1
  jlfmat[,i]=colvec
}
newprobimgs=matrixToImages( jlfmat, mk )
```


## Renormalize probabilities: *ANTsR* function

```{r renoprobs2,eval=TRUE}
jlf$probimgs[[ 1 ]] = newcsf
newprobimgs2 = renormalizeProbabilityImages(
  jlf$probimgs, mk, 1 )
```

## Segment new images with these modified priors

We can use the template, itself, as an example.

Obviously, we skip the registration step.

```{r tempseg}
segnew <- atropos( d = 3, a = t1tem, m = '[0.05,1x1x1]',
   c = '[2,0]',  i = newprobimgs2, x = mk )
```

A more complete process is available in `antsAtroposN4.sh` which
is what we use for production.

We might go further and force the posteriors to be zero
where the priors are zero ...

## Template and segmentation

```{r timg,echo=FALSE}
plot( t1tem , dorot = 1 , slices=10 )
```

## Template and *JLF* segmentation

```{r timg3,echo=FALSE}
plot( t1tem, jlf$segimg , dorot = 1 , slices=10 )
```

## Template and *Atropos* segmentation

```{r timg2,echo=FALSE}
plot( t1tem, segnew$segmentation , dorot = 1 , slices=10 )
```

## Try the same thing on a subject (need registration)

Let's do this as example later ...

## Summary

* Briefly reviewed PTBP and the modalities therein.

* We showed a quick registration option.

* We showed how to get the template "into shape" such that it can be used for processing new data.

* JLF is key to this process.

* We will discuss modality-specific processing and statistical testing procedures elsewhere.