6_Similarity_Metrics_and_Optimization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Similarity Metrics and Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Image Registration Method\n",
    "\n",
    "There are many options for creating an instance of the registration framework, all of which are configured in SimpleITK via methods of the <a href=\"http://www.itk.org/SimpleITKDoxygen/html/classitk_1_1simple_1_1ImageRegistrationMethod.html\">ImageRegistrationMethod</a> class. This class encapsulates many of the components available in ITK for constructing a registration instance.\n",
    "\n",
    "Supported pixel types are sitkFloat32 and sitkFloat64 (use the SimpleITK <a href=\"http://www.itk.org/SimpleITKDoxygen/html/namespaceitk_1_1simple.html#af8c9d7cc96a299a05890e9c3db911885\">Cast()</a> function if your image's pixel type is something else).\n",
    "\n",
    "![Registration Framework](Data/ITKv4RegistrationComponentsDiagram.svg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Similarity metrics\n",
    "\n",
    "The SimpleITK registration framework supports several metric types via the SetMetricAsX() methods, these include:\n",
    "\n",
    "<ul>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1MeanSquaresImageToImageMetricv4.html\">MeanSquares</a>\n",
    "  </li>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1DemonsImageToImageMetricv4.html\">Demons</a>\n",
    "  </li>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1CorrelationImageToImageMetricv4.html\">Correlation</a>\n",
    "  </li>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1ANTSNeighborhoodCorrelationImageToImageMetricv4.html\">ANTSNeighborhoodCorrelation</a>\n",
    "  </li>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1JointHistogramMutualInformationImageToImageMetricv4.html\">JointHistogramMutualInformation</a>\n",
    "  </li>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1MattesMutualInformationImageToImageMetricv4.html\">MattesMutualInformation</a>\n",
    "  </li>\n",
    "</ul>\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Optimizers\n",
    "\n",
    "The SimpleITK registration framework supports several optimizer types via the SetMetricAsX() methods, these include:\n",
    "\n",
    "<ul>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1ExhaustiveOptimizerv4.html\">Exhaustive</a>\n",
    "  </li>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1AmoebaOptimizerv4.html\">Nelder-Mead downhill simplex</a>, a.k.a. Amoeba.\n",
    "  </li>\n",
    "  <li>\n",
    "  Variations on gradient descent:\n",
    "  <ul>\n",
    "    <li>\n",
    "    <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1GradientDescentOptimizerv4Template.html\">GradientDescent</a>\n",
    "    </li>\n",
    "    <li>\n",
    "    <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1GradientDescentLineSearchOptimizerv4Template.html\">GradientDescentLineSearch</a>\n",
    "    </li>\n",
    "    <li>\n",
    "    <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1RegularStepGradientDescentOptimizerv4.html\">RegularStepGradientDescent</a>\n",
    "    </li>\n",
    "  </ul>\n",
    "  </li>\n",
    "  <li>\n",
    "    <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1ConjugateGradientLineSearchOptimizerv4Template.html\">ConjugateGradientLineSearch</a> \n",
    "  </li>\n",
    "  <li>\n",
    "  <a href=\"http://www.itk.org/Doxygen/html/classitk_1_1LBFGSBOptimizerv4.html\">L-BFGS-B</a> (Limited memory Broyden,  Fletcher,Goldfarb,Shannon-Bound Constrained) - supports the use of simple constraints ($l\\leq x \\leq u$)  \n",
    "  </li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tutorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Data -  Retrospective Image Registration Evaluation\n",
    "\n",
    "We will be using part of the training data from the Retrospective Image Registration Evaluation (<a href=\"http://www.insight-journal.org/rire/\">RIRE</a>) project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import SimpleITK as sitk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Utility functions\n",
    "A number of utility callback functions for image display and for ploting the similarity metric during registration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from ipywidgets import interact, fixed\n",
    "from IPython.display import clear_output\n",
    "\n",
    "# callback invoked by the interact ipython method for scrolling through the image stacks of\n",
    "# the two images (moving and fixed)\n",
    "def display_images(fixed_image_z, moving_image_z, fixed_npa, moving_npa):\n",
    "    # create a figure with two subplots and the specified size\n",
    "    plt.subplots(1,2,figsize=(10,8))\n",
    "    \n",
    "    # draw the fixed image in the first subplot\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.imshow(fixed_npa[fixed_image_z,:,:],cmap=plt.cm.Greys_r);\n",
    "    plt.title('fixed image')\n",
    "    plt.axis('off')\n",
    "    \n",
    "    # draw the moving image in the second subplot\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.imshow(moving_npa[moving_image_z,:,:],cmap=plt.cm.Greys_r);\n",
    "    plt.title('moving image')\n",
    "    plt.axis('off')\n",
    "\n",
    "# callback invoked by the ipython interact method for scrolling and modifying the alpha blending\n",
    "# of an image stack of two images that occupy the same physical space. \n",
    "def display_images_with_alpha(image_z, alpha, fixed, moving):\n",
    "    img = (1.0 - alpha)*fixed[:,:,image_z] + alpha*moving[:,:,image_z] \n",
    "    plt.imshow(sitk.GetArrayFromImage(img),cmap=plt.cm.Greys_r);\n",
    "    plt.axis('off')\n",
    "    \n",
    "    \n",
    "# callback invoked when the StartEvent happens, sets up our new data\n",
    "def start_plot():\n",
    "    global metric_values, multires_iterations\n",
    "    \n",
    "    metric_values = []\n",
    "    multires_iterations = []\n",
    "\n",
    "# callback invoked when the EndEvent happens, do cleanup of data and figure\n",
    "def end_plot():\n",
    "    global metric_values, multires_iterations\n",
    "    \n",
    "    del metric_values\n",
    "    del multires_iterations\n",
    "    #close figure, we don't want to get a duplicate of the plot latter on\n",
    "    plt.close()\n",
    "\n",
    "# callback invoked when the IterationEvent happens, update our data and display new figure    \n",
    "def plot_values(registration_method):\n",
    "    global metric_values, multires_iterations\n",
    "    \n",
    "    metric_values.append(registration_method.GetMetricValue())                                       \n",
    "    #clear the output area (wait=True, to reduce flickering), and plot current data\n",
    "    clear_output(wait=True)\n",
    "    #plot the similarity metric values\n",
    "    plt.plot(metric_values, 'r')\n",
    "    plt.plot(multires_iterations, [metric_values[index] for index in multires_iterations], 'b*')\n",
    "    plt.xlabel('Iteration Number',fontsize=12)\n",
    "    plt.ylabel('Metric Value',fontsize=12)\n",
    "    plt.show()\n",
    "    \n",
    "# callback invoked when the sitkMultiResolutionIterationEvent happens, update the index into the \n",
    "# metric_values list. \n",
    "def update_multires_iterations():\n",
    "    global metric_values, multires_iterations\n",
    "    multires_iterations.append(len(metric_values))        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Read images\n",
    "\n",
    "We first read the images, casting the pixel type to that required for registration (Float32 or Float64) and look at them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "fixed_image =  sitk.ReadImage(\"Data/training_001_ct.mha\",\n",
    "                              sitk.sitkFloat32)\n",
    "moving_image = sitk.ReadImage(\"Data/training_001_mr_T1.mha\",\n",
    "                              sitk.sitkFloat32) \n",
    "\n",
    "interact(display_images,\n",
    "         fixed_image_z=(0,fixed_image.GetSize()[2]-1),\n",
    "         moving_image_z=(0,moving_image.GetSize()[2]-1),\n",
    "         fixed_npa = fixed(sitk.GetArrayFromImage(fixed_image)),\n",
    "         moving_npa=fixed(sitk.GetArrayFromImage(moving_image)));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Initial Alignment\n",
    "\n",
    "Use the CenteredTransformInitializer to align the centers of the two volumes and set the center of rotation to the center of the fixed image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "centering_mode = sitk.CenteredTransformInitializerFilter.GEOMETRY\n",
    "initial_transform = \\\n",
    "    sitk.CenteredTransformInitializer(fixed_image, \n",
    "                                      moving_image, \n",
    "                                      sitk.Euler3DTransform(), \n",
    "                                      centering_mode)\n",
    "\n",
    "moving_resampled = sitk.Resample(moving_image,\n",
    "                                 fixed_image,\n",
    "                                 initial_transform,\n",
    "                                 sitk.sitkLinear,\n",
    "                                 0.0,\n",
    "                                 moving_image.GetPixelIDValue())\n",
    "\n",
    "interact(display_images_with_alpha,\n",
    "         image_z=(0,fixed_image.GetSize()[2]),\n",
    "         alpha=(0.0,1.0,0.05),\n",
    "         fixed = fixed(fixed_image),\n",
    "         moving=fixed(moving_resampled));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Registration\n",
    "\n",
    "The specific registration task at hand estimates a 3D rigid transformation between images of different modalities. There are multiple components from each group (optimizers, similarity metrics, interpolators) that are appropriate for the task. Note that each component selection requires setting some parameter values. We have made the following choices:\n",
    "\n",
    "<ul>\n",
    "<li>Similarity metric, mutual information (Mattes MI):\n",
    "<ul>\n",
    "  <li>Number of histogram bins, 50.</li>\n",
    "  <li>Sampling strategy, random.</li>\n",
    "  <li>Sampling percentage, 1%.</li>\n",
    "</ul>\n",
    "</li>\n",
    "<li>Interpolator, sitkLinear.</li>\n",
    "<li>Optimizer, gradient descent: \n",
    "<ul>\n",
    "  <li>Learning rate, step size along traversal direction in parameter space, 1.0 .</li>\n",
    "  <li>Number of iterations, maximal number of iterations, 100.</li>\n",
    "  <li>Convergence minimum value, value used for convergence checking in conjunction with the energy profile of the similarity metric that is estimated in the given window size, 1e-6.</li>\n",
    "  <li>Convergence window size, number of values of the similarity metric which are used to estimate the energy profile of the similarity metric, 10.</li>\n",
    "</ul>\n",
    "</li>\n",
    "</ul>\n",
    "\n",
    "\n",
    "Perform registration using the settings given above, and take advantage of the built in multi-resolution framework, use a three tier pyramid.  \n",
    "\n",
    "In this example we plot the similarity metric's value during regisration. Note that the change of scales in the multi-resolution framework is readily visible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "registration = sitk.ImageRegistrationMethod()\n",
    "\n",
    "# similarity metric settings\n",
    "registration.SetMetricAsMattesMutualInformation(numberOfHistogramBins=50)\n",
    "registration.SetMetricSamplingStrategy(registration.RANDOM)\n",
    "registration.SetMetricSamplingPercentage(0.01)\n",
    "\n",
    "registration.SetInterpolator(sitk.sitkLinear)\n",
    "\n",
    "# optimizer settings\n",
    "registration.SetOptimizerAsGradientDescent(learningRate=1.0,\n",
    "                                           numberOfIterations=100,\n",
    "                                           convergenceMinimumValue=1e-6,\n",
    "                                           convergenceWindowSize=10)\n",
    "registration.SetOptimizerScalesFromPhysicalShift()\n",
    "\n",
    "# setup for the multi-resolution framework            \n",
    "registration.SetShrinkFactorsPerLevel(shrinkFactors = [4,2,1])\n",
    "registration.SetSmoothingSigmasPerLevel(smoothingSigmas=[2,1,0])\n",
    "registration.SmoothingSigmasAreSpecifiedInPhysicalUnitsOn()\n",
    "\n",
    "# don't optimize in-place, we would possibly like to run this cell multiple times\n",
    "registration.SetInitialTransform(initial_transform, inPlace=False)\n",
    "\n",
    "# connect all of the observers so that we can perform plotting during registration\n",
    "registration.AddCommand(sitk.sitkStartEvent, start_plot)\n",
    "registration.AddCommand(sitk.sitkEndEvent, end_plot)\n",
    "registration.AddCommand(sitk.sitkMultiResolutionIterationEvent,\n",
    "                        update_multires_iterations) \n",
    "registration.AddCommand(sitk.sitkIterationEvent,\n",
    "                        lambda: plot_values(registration))\n",
    "\n",
    "fixed_image_float = sitk.Cast(fixed_image, sitk.sitkFloat32)\n",
    "moving_image_float = sitk.Cast(moving_image, sitk.sitkFloat32)\n",
    "\n",
    "final_transform = registration.Execute(fixed_image_float,\n",
    "                                       moving_image_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Post registration analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Query the registration method to see the metric value and the reason the optimization terminated. \n",
    "\n",
    "The metric value allows us to compare multiple registration runs as there is a probabilistic aspect to our registration, we are using random sampling to estimate the similarity metric.\n",
    "\n",
    "Always remember to query why the optimizer terminated. This will help you understand whether termination is too early, either due to thresholds being too tight, early termination due to small number of iterations - numberOfIterations, or too loose, early termination due to large value for minimal change in similarity measure - convergenceMinimumValue)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print('Final metric value: {0}'.format(registration.GetMetricValue()))\n",
    "print('Optimizer\\'s stopping condition, {0}'.format(                                               \n",
    "    registration.GetOptimizerStopConditionDescription()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Now visually inspect the results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "moving_resampled = sitk.Resample(moving_image,\n",
    "                                 fixed_image,\n",
    "                                 final_transform,\n",
    "                                 sitk.sitkLinear,\n",
    "                                 0.0,\n",
    "                                 moving_image.GetPixelIDValue())\n",
    "\n",
    "interact(display_images_with_alpha,\n",
    "         image_z=(0,fixed_image.GetSize()[2]),\n",
    "         alpha=(0.0,1.0,0.05),\n",
    "         fixed = fixed(fixed_image),\n",
    "         moving=fixed(moving_resampled));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we are satisfied with the results, save them to file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "sitk.WriteImage(moving_resampled, 'RIRE_training_001_mr_T1_resampled.mha')\n",
    "sitk.WriteTransform(final_transform, 'RIRE_training_001_CT_2_mr_T1.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Exercises\n",
    "\n",
    "There is plenty more to learn! There are more registration techniques outside of the primary registration framework. There are many segmentation methods. And there are many powerful filtering methods. Continue the adventure at\n",
    "\n",
    "- http://simpleitk.org\n",
    "- http://itk.org\n",
    "\n",
    "Enjoy ITK!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}