Merge pull request #32 from jni/filter-improvements

Improvements to filters lesson

Author: JDWarner

lectures/1_image_filters.ipynb

@@ -372,11 +372,11 @@
    },
    "outputs": [],
    "source": [
-    "from scipy.ndimage import convolve\n",
+    "import scipy.ndimage as ndi\n",
     "\n",
     "%precision 2\n",
     "print(bright_square)\n",
-    "print(convolve(bright_square, mean_kernel))"
+    "print(ndi.convolve(bright_square, mean_kernel))"
    ]
   },
   {
@@ -409,7 +409,7 @@
    "source": [
     "Let's see a convolution in action.\n",
     "\n",
-    "(Execute the following cell, but don't try to read it; it's purpose is to generate an example.)"
+    "(Execute the following cell, but don't try to read it; its purpose is to generate an example.)"
    ]
   },
   {
@@ -502,6 +502,13 @@
     "mean_filter_interactive_demo(bright_square)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Incidentally, the above filtering is the exact same principle behind the *convolutional neural networks*, or CNNs, that you might have heard much about over the past few years. The only difference is that while above, the simple mean kernel is used, in CNNs, the values inside the kernel are *learned* to find a specific feature, or accomplish a specific task."
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {
@@ -655,8 +662,8 @@
    },
    "outputs": [],
    "source": [
-    "filtered = convolve(pixelated, mean_kernel)\n",
-    "imshow_all(pixelated, filtered)"
+    "filtered = ndi.convolve(pixelated, mean_kernel)\n",
+    "imshow_all(pixelated, filtered, titles=['pixelated', 'mean filtered'])"
    ]
   },
   {
@@ -689,7 +696,7 @@
     }
    },
    "source": [
-    "If you read through the last section, you're already familiar with the essential concepts of image filtering. But, of course, you don't have to create custom filter kernels for all of your filtering needs.\n"
+    "If you read through the last section, you're already familiar with the essential concepts of image filtering. But, of course, you don't have to create custom filter kernels for all of your filtering needs. There are many standard filter kernels pre-defined from half a century of image and signal processing."
    ]
   },
   {
@@ -727,7 +734,7 @@
     "# Rename module so we don't shadow the builtin function\n",
     "from skimage import filters\n",
     "\n",
-    "smooth_mean = convolve(bright_square, mean_kernel)\n",
+    "smooth_mean = ndi.convolve(bright_square, mean_kernel)\n",
     "sigma = 1\n",
     "smooth = filters.gaussian(bright_square, sigma)\n",
     "imshow_all(bright_square, smooth_mean, smooth,\n",
@@ -761,7 +768,7 @@
     "# The Gaussian filter returns a float image, regardless of input.\n",
     "# Cast to float so the images have comparable intensity ranges.\n",
     "pixelated_float = img_as_float(pixelated)\n",
-    "smooth = filters.gaussian(pixelated_float, 1)\n",
+    "smooth = filters.gaussian(pixelated_float, sigma=1)\n",
     "imshow_all(pixelated_float, smooth)"
    ]
   },
@@ -802,7 +809,52 @@
     }
    },
    "source": [
-    "The size of the structuring element used for the mean filter and the size (standard deviation) of the Gaussian filter are tweaked to produce an approximately equal amount of smoothing in the two results."
+    "(Above, we've tweaked the size of the structuring element used for the mean filter and the standard deviation of the Gaussian filter to produce an approximately equal amount of smoothing in the two results.)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Incidentally, for reference, let's have a look at what the Gaussian filter actually looks like. Technically, the value of the kernel at a pixel that is $r$ rows and $c$ cols from the center is:\n",
+    "\n",
+    "$$\n",
+    "k_{r, c} = \\frac{1}{2\\pi \\sigma} \\exp{\\left(-\\frac{r^2 + c^2}{2\\sigma^2}\\right)}\n",
+    "$$\n",
+    "\n",
+    "Practically speaking, this value is pretty close to zero for values more than $4\\sigma$ away from the center, so practical Gaussian filters are truncated at about $4\\sigma$:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sidelen = 45\n",
+    "sigma = (sidelen - 1) // 2 // 4\n",
+    "spot = np.zeros((sidelen, sidelen), dtype=float)\n",
+    "spot[sidelen // 2, sidelen // 2] = 1\n",
+    "kernel = filters.gaussian(spot, sigma=sigma)\n",
+    "\n",
+    "imshow_all(spot, kernel / np.max(kernel))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's look at a side view of that Gaussian \"bump\":"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, ax = plt.subplots()\n",
+    "ax.plot(kernel[sidelen//2])"
    ]
   },
   {
@@ -899,7 +951,9 @@
    "outputs": [],
    "source": [
     "fig, ax = plt.subplots()\n",
-    "ax.plot(step_signal, 'b:', change, 'r')\n",
+    "ax.plot(step_signal, label='signal')\n",
+    "ax.plot(change, linestyle='dashed', label='change')\n",
+    "ax.legend(loc='upper left')\n",
     "ax.margins(0.1)"
    ]
   },
@@ -936,7 +990,9 @@
    "source": [
     "noisy_change = ndi.convolve(noisy_signal, np.array([1, 0, -1]))\n",
     "fig, ax = plt.subplots()\n",
-    "ax.plot(noisy_signal, 'b:', noisy_change, 'r')\n",
+    "ax.plot(noisy_signal, label='signal')\n",
+    "ax.plot(noisy_change, linestyle='dashed', label='change')\n",
+    "ax.legend(loc='upper left')\n",
     "ax.margins(0.1)"
    ]
   },
@@ -963,7 +1019,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "*Note:* I use `np.convolve` here, because it has the option to output a *wider* result than either of the two inputs."
+    "*Note:* we use `np.convolve` here, because it has the option to output a *wider* result than either of the two inputs."
    ]
   },
   {
@@ -981,9 +1037,10 @@
    "source": [
     "smooth_change = ndi.convolve(noisy_signal, mean_diff)\n",
     "fig, ax = plt.subplots()\n",
-    "ax.plot(noisy_signal, 'b:', smooth_change, 'r')\n",
+    "ax.plot(noisy_signal, label='signal')\n",
+    "ax.plot(smooth_change, linestyle='dashed', label='change')\n",
     "ax.margins(0.1)\n",
-    "ax.hlines([-0.5, 0.5], 0, 100, linewidth=0.5);"
+    "ax.hlines([-0.5, 0.5], 0, 100, linewidth=0.5, color='gray');"
    ]
   },
   {
@@ -1024,8 +1081,10 @@
     "    [-1, -1, -1]\n",
     "])\n",
     "\n",
-    "gradient_vertical = ndi.convolve(pixelated.astype(float), vertical_kernel)\n",
-    "plt.imshow(gradient_vertical);"
+    "gradient_vertical = ndi.convolve(pixelated.astype(float),\n",
+    "                                 vertical_kernel)\n",
+    "fig, ax = plt.subplots()\n",
+    "ax.imshow(gradient_vertical);"
    ]
   },
   {
@@ -1185,7 +1244,7 @@
     }
    },
    "source": [
-    "This is a bit arbitrary, but here, we distinguish smoothing filters from denoising filters. We'll label denoising filters as those that are edge preserving.\n",
+    "At this point, we make a distinction. The earlier filters were implemented as a *linear dot-product* of values in the filter kernel and values in the image. The following kernels implement an *arbitrary* function of the local image neighborhood. Denoising filters in particular are filters that preserve the sharpness of edges in the image.\n",
     "\n",
     "As you can see from our earlier examples, mean and Gaussian filters smooth an image rather uniformly, including the edges of objects in an image. When denoising, however, you typically want to preserve features and just remove noise. The distinction between noise and features can, of course, be highly situation-dependent and subjective."
    ]
@@ -1223,8 +1282,8 @@
    "outputs": [],
    "source": [
     "from skimage.morphology import disk\n",
-    "selem = disk(1)  # \"selem\" is often the name used for \"structuring element\"\n",
-    "median = filters.rank.median(pixelated, selem)\n",
+    "neighborhood = disk(radius=1)  # \"selem\" is often the name used for \"structuring element\"\n",
+    "median = filters.rank.median(pixelated, neighborhood)\n",
     "titles = ['image', 'gaussian', 'median']\n",
     "imshow_all(pixelated, smooth, median, titles=titles)"
    ]
@@ -1250,10 +1309,10 @@
    },
    "outputs": [],
    "source": [
-    "selem = disk(10)\n",
+    "neighborhood = disk(10)\n",
     "coins = data.coins()\n",
-    "mean_coin = filters.rank.mean(coins, selem)\n",
-    "median_coin = filters.rank.median(coins, selem)\n",
+    "mean_coin = filters.rank.mean(coins, neighborhood)\n",
+    "median_coin = filters.rank.median(coins, neighborhood)\n",
     "titles = ['image', 'mean', 'median']\n",
     "imshow_all(coins, mean_coin, median_coin, titles=titles)"
    ]
@@ -1321,7 +1380,7 @@
     "* [Rank filters example](http://scikit-image.org/docs/dev/auto_examples/applications/plot_rank_filters.html)\n",
     "* [Restoration API](http://scikit-image.org/docs/stable/api/skimage.restoration.html)\n",
     "\n",
-    "Take a look at this [neat feature](https://github.com/scikit-image/scikit-image/pull/2647) that just got merged:\n",
+    "Take a look at this [neat feature](https://github.com/scikit-image/scikit-image/pull/2647) merged last year:\n",
     "\n",
     "![cycle spinning](../images/cycle_spin.png)"
    ]
@@ -1343,7 +1402,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.0"
+   "version": "3.6.3"
   }
  },
  "nbformat": 4,

lectures/3_morphological_operations.ipynb

@@ -31,9 +31,7 @@
    "source": [
     "import numpy as np\n",
     "from matplotlib import pyplot as plt, cm\n",
-    "import skdemo\n",
-    "plt.rcParams['image.cmap'] = 'cubehelix'\n",
-    "plt.rcParams['image.interpolation'] = 'none'"
+    "import skdemo"
    ]
   },
   {
@@ -265,9 +263,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.3"
+   "version": "3.6.3"
   }
  },
  "nbformat": 4,
- "nbformat_minor": 0
+ "nbformat_minor": 1
 }