2_Image_Filtering.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Image Filtering"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Learning Objectives\n",
    "\n",
    "* Understand the image processing pipeline model used in ITK\n",
    "* Understand what image streaming is, and how it is used in ITK\n",
    "* Gain familiarity with some of the filtering algorithms available in ITK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "While **data objects** (e.g., [Images](https://itk.org/ITKSoftwareGuide/html/Book1/ITKSoftwareGuide-Book1ch4.html#x40-440004.1) and [Meshes](https://itk.org/ITKSoftwareGuide/html/Book1/ITKSoftwareGuide-Book1ch4.html#x40-590004.3)) are used to represent data, **process objects** are classes that operate on data objects and may produce new data objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Process objects are classed as sources, filter objects, or mappers.\n",
    "\n",
    "**Sources** (such as readers) produce data, **filter** objects take in data and process it to produce new data, and **mappers** accept data for output either to a file or some other system. \n",
    "\n",
    "Sometimes the term *filter* is used broadly to refer to all three types.\n",
    "\n",
    "![Data pipeline](data/data-pipeline.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Typically **data objects** and **process objects** are connected together using the `SetInput()` and `GetOutput()` methods.\n",
    "\n",
    "Generation of new outputs and pixel data does not occur until the `Update()` method is called on the **end** of the pipeline (on the process object or the data object).\n",
    "\n",
    "![Pipeline updates](data/pipeline-updates.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The **data** associated with multi-dimensional images **is large and becoming larger**. \n",
    "\n",
    "Any practical image analysis system must address this fact in order to be useful in applications with multi-dimensional images. ITK addresses this problem via its **data streaming** facility.\n",
    "\n",
    "![Streaming](data/streaming.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Streaming is performed by splitting the image into non-overlapping **regions** at the **end of the pipeline**. The *RequestedRegion* then propagates up the pipeline.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "There are three named [ImageRegion](https://itk.org/Insight/Doxygen/html/classitk_1_1ImageRegion.html)'s encountered in ITK:\n",
    "\n",
    "- *BufferedRegion*: The region of pixels stored in memory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- *LargestPossibleRegion*: The largest possible region of an image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- *RequestedRegion*: The region requested on a single processing pass when streaming. The BufferedRegion and LargestPossibleRegion are as large or larger than the RequestedRegion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "For more information, see,\n",
    "\n",
    "- The [*Filtering* chapter](https://itk.org/ITKSoftwareGuide/html/Book2/ITKSoftwareGuide-Book2ch2.html#x17-320002) of Book 2 of the ITK Software Guide.\n",
    "- The [*Data Processing Pipeline* section](https://itk.org/ITKSoftwareGuide/html/Book1/ITKSoftwareGuide-Book1ch3.html#x39-420003.5) of the *System Overview* chapter of Book 1 of the ITK Software Guide.\n",
    "- The [*Data Representation* chapter](https://itk.org/ITKSoftwareGuide/html/Book1/ITKSoftwareGuide-Book1ch4.html#x45-490004) of Book 1 of the ITK Software Guide."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import itk\n",
    "from itkwidgets import view"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can monitor when a filter gets called by registering a command that gets called when [ProgressEvents](https://itk.org/Doxygen/html/classitk_1_1ProgressEvent.html) occur.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "itk.auto_progress(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Start an image processing pipeline with a source, an `ImageFileReader`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading ITKPyBase... done\n",
      "Loading ITKCommon... done\n",
      "Loading ITKIOImageBase... done\n",
      "Loading ITKPyUtils... done\n"
     ]
    }
   ],
   "source": [
    "fileName = 'data/PacMan.png'\n",
    "reader = itk.ImageFileReader.New(FileName=fileName)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Next, let's create a smoothing filter. To connect the pipeline, specify the `Output` of the reader as the `Input` to the smoother."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading ITKStatistics... done\n",
      "Loading ITKImageFilterBase... done\n",
      "Loading ITKTransform... done\n",
      "Loading ITKImageFunction... done\n",
      "Loading ITKSmoothing... done\n"
     ]
    }
   ],
   "source": [
    "smoother = itk.RecursiveGaussianImageFilter.New(Input=reader.GetOutput())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "At this point, no output images have been generated.\n",
    "\n",
    "We have configured the simple pipeline:\n",
    "\n",
    "reader -> smoother"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reader's Output: Image (0x55d4dead6c60)\n",
      "  RTTI typeinfo:   itk::Image<unsigned char, 2u>\n",
      "  Reference Count: 3\n",
      "  Modified Time: 155\n",
      "  Debug: Off\n",
      "  Object Name: \n",
      "  Observers: \n",
      "    none\n",
      "  Source: (0x55d4de5412b0) \n",
      "  Source output name: Primary\n",
      "  Release Data: Off\n",
      "  Data Released: False\n",
      "  Global Release Data: Off\n",
      "  PipelineMTime: 0\n",
      "  UpdateMTime: 0\n",
      "  RealTimeStamp: 0 seconds \n",
      "  LargestPossibleRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [0, 0]\n",
      "  BufferedRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [0, 0]\n",
      "  RequestedRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [0, 0]\n",
      "  Spacing: [1, 1]\n",
      "  Origin: [0, 0]\n",
      "  Direction: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  IndexToPointMatrix: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  PointToIndexMatrix: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  Inverse Direction: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  PixelContainer: \n",
      "    ImportImageContainer (0x55d4e0d0c800)\n",
      "      RTTI typeinfo:   itk::ImportImageContainer<unsigned long, unsigned char>\n",
      "      Reference Count: 1\n",
      "      Modified Time: 152\n",
      "      Debug: Off\n",
      "      Object Name: \n",
      "      Observers: \n",
      "        none\n",
      "      Pointer: 0\n",
      "      Container manages memory: true\n",
      "      Size: 0\n",
      "      Capacity: 0\n",
      "\n",
      "smoother's Output: Image (0x55d4e0e4f660)\n",
      "  RTTI typeinfo:   itk::Image<unsigned char, 2u>\n",
      "  Reference Count: 2\n",
      "  Modified Time: 174\n",
      "  Debug: Off\n",
      "  Object Name: \n",
      "  Observers: \n",
      "    none\n",
      "  Source: (0x55d4e0e91480) \n",
      "  Source output name: Primary\n",
      "  Release Data: Off\n",
      "  Data Released: False\n",
      "  Global Release Data: Off\n",
      "  PipelineMTime: 0\n",
      "  UpdateMTime: 0\n",
      "  RealTimeStamp: 0 seconds \n",
      "  LargestPossibleRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [0, 0]\n",
      "  BufferedRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [0, 0]\n",
      "  RequestedRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [0, 0]\n",
      "  Spacing: [1, 1]\n",
      "  Origin: [0, 0]\n",
      "  Direction: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  IndexToPointMatrix: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  PointToIndexMatrix: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  Inverse Direction: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  PixelContainer: \n",
      "    ImportImageContainer (0x55d4e0609a70)\n",
      "      RTTI typeinfo:   itk::ImportImageContainer<unsigned long, unsigned char>\n",
      "      Reference Count: 1\n",
      "      Modified Time: 171\n",
      "      Debug: Off\n",
      "      Object Name: \n",
      "      Observers: \n",
      "        none\n",
      "      Pointer: 0\n",
      "      Container manages memory: true\n",
      "      Size: 0\n",
      "      Capacity: 0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"reader's Output: %s\" % reader.GetOutput())\n",
    "print(\"smoother's Output: %s\" % smoother.GetOutput())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To generate the filter outputs, we must call `Update()` on the filter at the end of the pipeline. In this case, it is the smoother."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reader's Output: Image (0x55d4dead6c60)\n",
      "  RTTI typeinfo:   itk::Image<unsigned char, 2u>\n",
      "  Reference Count: 3\n",
      "  Modified Time: 337\n",
      "  Debug: Off\n",
      "  Object Name: \n",
      "  Observers: \n",
      "    none\n",
      "  Source: (0x55d4de5412b0) \n",
      "  Source output name: Primary\n",
      "  Release Data: Off\n",
      "  Data Released: False\n",
      "  Global Release Data: Off\n",
      "  PipelineMTime: 165\n",
      "  UpdateMTime: 338\n",
      "  RealTimeStamp: 0 seconds \n",
      "  LargestPossibleRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [128, 128]\n",
      "  BufferedRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [128, 128]\n",
      "  RequestedRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [128, 128]\n",
      "  Spacing: [1, 1]\n",
      "  Origin: [0, 0]\n",
      "  Direction: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  IndexToPointMatrix: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  PointToIndexMatrix: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  Inverse Direction: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  PixelContainer: \n",
      "    ImportImageContainer (0x55d4e0d0c800)\n",
      "      RTTI typeinfo:   itk::ImportImageContainer<unsigned long, unsigned char>\n",
      "      Reference Count: 1\n",
      "      Modified Time: 335\n",
      "      Debug: Off\n",
      "      Object Name: \n",
      "      Observers: \n",
      "        none\n",
      "      Pointer: 0x55d4e14767b0\n",
      "      Container manages memory: true\n",
      "      Size: 16384\n",
      "      Capacity: 16384\n",
      "\n",
      "smoother's Output: Image (0x55d4e0e4f660)\n",
      "  RTTI typeinfo:   itk::Image<unsigned char, 2u>\n",
      "  Reference Count: 2\n",
      "  Modified Time: 342\n",
      "  Debug: Off\n",
      "  Object Name: \n",
      "  Observers: \n",
      "    none\n",
      "  Source: (0x55d4e0e91480) \n",
      "  Source output name: Primary\n",
      "  Release Data: Off\n",
      "  Data Released: False\n",
      "  Global Release Data: Off\n",
      "  PipelineMTime: 329\n",
      "  UpdateMTime: 343\n",
      "  RealTimeStamp: 0 seconds \n",
      "  LargestPossibleRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [128, 128]\n",
      "  BufferedRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [128, 128]\n",
      "  RequestedRegion: \n",
      "    Dimension: 2\n",
      "    Index: [0, 0]\n",
      "    Size: [128, 128]\n",
      "  Spacing: [1, 1]\n",
      "  Origin: [0, 0]\n",
      "  Direction: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  IndexToPointMatrix: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  PointToIndexMatrix: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  Inverse Direction: \n",
      "1 0\n",
      "0 1\n",
      "\n",
      "  PixelContainer: \n",
      "    ImportImageContainer (0x55d4e0609a70)\n",
      "      RTTI typeinfo:   itk::ImportImageContainer<unsigned long, unsigned char>\n",
      "      Reference Count: 1\n",
      "      Modified Time: 340\n",
      "      Debug: Off\n",
      "      Object Name: \n",
      "      Observers: \n",
      "        none\n",
      "      Pointer: 0x55d4e0de7690\n",
      "      Container manages memory: true\n",
      "      Size: 16384\n",
      "      Capacity: 16384\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Running itkImageFileReaderIUC2... done\n",
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "smoother.Update()\n",
    "\n",
    "print(\"reader's Output: %s\" % reader.GetOutput())\n",
    "print(\"smoother's Output: %s\" % smoother.GetOutput())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let's view the images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading ITKBridgeNumPy... done\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1e119ec5d554462ab6ae1a9ed9d8c604",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Vmlld2VyKGdyYWRpZW50X29wYWNpdHk9MC4yMiwgcmVuZGVyZWRfaW1hZ2U9PGl0a0ltYWdlUHl0aG9uLml0a0ltYWdlVUMyOyBwcm94eSBvZiA8U3dpZyBPYmplY3Qgb2YgdHlwZSAnaXRrSW3igKY=\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "image = reader.GetOutput()\n",
    "view(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d97431f90a42472db3eb700fa8a54d59",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Vmlld2VyKGdyYWRpZW50X29wYWNpdHk9MC4yMiwgcmVuZGVyZWRfaW1hZ2U9PGl0a0ltYWdlUHl0aG9uLml0a0ltYWdlVUMyOyBwcm94eSBvZiA8U3dpZyBPYmplY3Qgb2YgdHlwZSAnaXRrSW3igKY=\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "smoothed = smoother.GetOutput()\n",
    "view(smoothed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If we call `Update()` on the pipeline, the output pixel data is not needlessly generated because the pipeline is up-to-date."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "smoother.Update()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "However, if we change the amount of smoothing, new pixel data does need to be generated from the output of the smoother."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "smoother.SetSigma(10.0)\n",
    "smoother.Update()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f63c68927f8248f496dd329846b541c8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Vmlld2VyKGdyYWRpZW50X29wYWNpdHk9MC4yMiwgcmVuZGVyZWRfaW1hZ2U9PGl0a0ltYWdlUHl0aG9uLml0a0ltYWdlVUMyOyBwcm94eSBvZiA8U3dpZyBPYmplY3Qgb2YgdHlwZSAnaXRrSW3igKY=\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "view(smoothed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Note, however, note that the reader does generate its output because it is up-to-date and upstream from the smoother.\n",
    "\n",
    "If we artificially modify the reader, both the reader and the smoother need to regenerate their outputs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Running itkImageFileReaderIUC2... done\n",
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "reader.Modified()\n",
    "\n",
    "smoother.Update()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can stream the pipeline by placing a [StreamingImageFilter](https://itk.org/Doxygen/html/classitk_1_1StreamingImageFilter.html) at the **end** of the pipeline. The smoother generates outputs multiple times, once for each image region streaming division. Since the reader is not capable of streaming, it only generates its output once."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Running itkStreamingImageFilterIUC2IUC2... Running itkImageFileReaderIUC2... done\n",
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n",
      "Running itkStreamingImageFilterIUC2IUC2... Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n",
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "streamer = itk.StreamingImageFilter.New(Input=smoother.GetOutput())\n",
    "streamer.SetNumberOfStreamDivisions(3)\n",
    "reader.Modified()\n",
    "streamer.Update()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A file writer can also stream data if the output format supports it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n",
      "Running itkImageFileWriterIUC2... Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n",
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n",
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n",
      "Running itkRecursiveGaussianImageFilterIUC2IUC2... done\n",
      "done\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "writer = itk.ImageFileWriter.New(Input=smoother.GetOutput())\n",
    "writer.SetFileName('my_output.mha')\n",
    "writer.SetNumberOfStreamDivisions(5)\n",
    "writer.Update()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 1: The effect of Sigma\n",
    "\n",
    "Change the value of Sigma on the smoothing filter.\n",
    "\n",
    "- How is the output effected?\n",
    "- What are the units of Sigma?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# fileName = 'data/PacMan.png'\n",
    "# reader = itk.ImageFileReader.New(FileName=fileName)\n",
    "# smoother = itk.RecursiveGaussianImageFilter.New(Input=reader.GetOutput())\n",
    "# smoother.SetSigma(XX)\n",
    "# smoother.Update()\n",
    "# view(smoother.GetOutput())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# %load solutions/2_Image_Filtering_Exercise1.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 2: Does setting a filter parameter to its current value cause regeneration of its output?\n",
    "\n",
    "Call `smoother.SetSigma(smoother.GetSigma())` then `smoother.Update()`. \n",
    "\n",
    "- Is the output regenerated? \n",
    "- Is this expected / desirable?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# %load solutions/2_Image_Filtering_Exercise2.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 3: Find other image filtering algorithms\n",
    "\n",
    "The classes in ITK are organized into **Modules**, and collections of Modules are organized into **Groups**. Examine the [Image Smoothing](https://itk.org/Doxygen/html/group__ITKSmoothing.html) Module and the [Filtering](https://itk.org/Doxygen/html/group__Group-Filtering.html) Group. Can any other smoothing or denoising classes be found? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# %load solutions/2_Image_Filtering_Exercise3.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercise 4: Test different output format with streaming\n",
    "\n",
    "Not all file format support streaming. Test several of them and see which ones support it and which ones do not.\n",
    "Hint 1: To select a file format, select the corresponding file extension.\n",
    "Hint 2: Examples of file format: `jpg`, \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# %load solutions/2_Image_Filtering_Exercise4.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enjoy ITK!"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}