SimpleITK/Tutorials/MICCAI2015

Monday October 5'th 2015

Who Should Attend

• Do you want your students to gain practical experience with registration while minimizing their programming load?
• Do you want to easily experiment with various ITK registration configurations, or optimize the settings of a specific registration configuration?

If you answered yes to either of these questions, then this tutorial is for you.

The goal of this half-day tutorial is to introduce students and researchers to SimpleITK’s interface for the ITK version 4 registration framework. SimpleITK is, as the name suggests, a simpler interface to ITK. It provides a procedural interface and bindings to several interpreted languages, facilitating fast experimentation with ITK algorithms. In this tutorial we will use the Python programming language and the IPython Notebook interactive environment to explore the various features of the ITKv4 registration framework. Key features presented include: uniform treatment of linear, deformable and composite transformations, embedded multi-resolution registration and self calibrating optimizers. Using a hands on approach, participants will experiment with various registration tasks, learning how to use SimpleITK in order to gain insight into the effects of registration component selection and parameter settings on accuracy and running time of ITK based registration algorithms.

Organizers

• Brian Avants, University of Pennsylvania.
• Hans Johnson, University of Iowa.
• Bradley Lowekamp, Medical Science & Computing and National Institutes of Health.
• Matthew McCormick, Kitware Inc.
• Nick Tustison, University of Virginia.
• Ziv Yaniv, TAJ Technologies Inc. and National Institutes of Health.

Prerequisites

We do not require knowledge of C++ templates, CMake or how to compile code.

We do require basic knowledge of the Python programming language. If you are not familiar with Python but are well versed in MATLAB, Java, C++... then don't worry. You will be up to speed with a minimal investment of time. Please read or skim through the official Python language tutorial or any of the tutorials listed here.

You will need to bring your laptop (don't forget the adapter plug for your power cord if you are coming from outside of Europe).

The minimal installation of python will have to include the following packages: (1) ipython; (2) numpy; (3) matplotlib; (4) SimpleITK

Two paths forward:

Lean and Mean

This path installs the minimal set of required components. We assume your system has a working compiler:

0. Download and install Python version 2.7.9.

From the command line:

1. if pip is not installed: (sudo) easy_install pip
2. (sudo) pip install virtualenv
3. virtualenv ~/sitkpy --no-site-packages
4. ~/sitkpy/bin/pip install ipython[all]
5. ~/sitkpy/bin/pip install numpy
6. ~/sitkpy/bin/pip install matplotlib
7. ~/sitkpy/bin/pip install SimpleITK (for other options see here)

Disk Space is Cheap

This path installs a full fledged scientific computing environment. Install (free) Python distributions for scientific and numeric computing from commercial vendors, either Continuum’s Anaconda or Enthought’s Canopy. If you want the full list of packages installed for each of these distributions simply follow these links:Anaconda, Canopy.

Anaconda Download and install. From the command line: conda update conda conda update anaconda conda create -n sitkpy anaconda unix/mac: source activate sitkpy, win: activate sitkpy conda install -c https://conda.binstar.org/simpleitk SimpleITK

Canopy Download and install. Update the installation using the Package Manager. From the command line (cd to the directory where canopy is installed): User/bin/canopy_cli venv -s sitkpy unix/mac: source sitkpy/bin/activate, win: sitkpy\Scripts\activate download the wheel from SourceForge as described here pip install wheel_file_name

Tentative Program

• 8:30am: Setup and introduction.
• 9:00am: SimpleITK basics: loading data, image access, image transformations, image resampling, basic filters.
• 10:00am: Coffee break.
• 10:30am: Registration 1: composite transform, transformation initialization, embedded multi-resolution, scale parameter estimation, optimization termination criteria.
• 11:30am: Registration 2: nonrigid registration - Nonrigid registration, Bspline and displacement field transformations.
• 12:30pm: Lunch.

A Taste of What's to Come: SimpleITK Registration, It's Really Simple

The following script illustrates the use of SimpleITK to perform rigid registration between a CT and MR (registration specific code is highlighted). By the end of the tutorial you will be familiar with the various components that are available as part of the SimpleITK registration framework, easily modifying this example to suite your specific needs.

<source lang="python" highlight="8-28"> import SimpleITK as sitk

1. read the images

fixed_image = sitk.ReadImage('training_001_ct.mha', sitk.sitkFloat32) moving_image = sitk.ReadImage('training_001_mr_T1.mha', sitk.sitkFloat32)

1. initial alignment of the two volumes

transform = sitk.CenteredTransformInitializer(fixed_image,

                                             moving_image, 
                                             sitk.Euler3DTransform(), 
                                             sitk.CenteredTransformInitializerFilter.GEOMETRY)

1. multi-resolution rigid registration using Mutual Information

registration_method = sitk.ImageRegistrationMethod() registration_method.SetMetricAsMattesMutualInformation(numberOfHistogramBins=50) registration_method.SetMetricSamplingStrategy(registration_method.RANDOM) registration_method.SetMetricSamplingPercentage(0.01) registration_method.SetInterpolator(sitk.sitkLinear) registration_method.SetOptimizerAsGradientDescent(learningRate=1.0,

                                                 numberOfIterations=100, 
                                                 convergenceMinimumValue=1e-6, 
                                                 convergenceWindowSize=10)

registration_method.SetOptimizerScalesFromPhysicalShift() registration_method.SetShrinkFactorsPerLevel(shrinkFactors = [4,2,1]) registration_method.SetSmoothingSigmasPerLevel(smoothingSigmas=[2,1,0]) registration_method.SmoothingSigmasAreSpecifiedInPhysicalUnitsOn() registration_method.SetInitialTransform(transform) registration_method.Execute(fixed_image, moving_image)

sitk.WriteTransform(transform, 'ct2mrT1.tfm') </source>

To run this example you will need to download the CT and MR data. These are part of the training data provided by the Retrospective Image Registration Evaluation Project.

A bit of additional code also allows us to visually follow the registration process: