explain motivation for kernel size/shape exercises

Author: tobyhodges

episodes/06-blurring.md

@@ -32,8 +32,8 @@ background of the image ends and the object begins.
 
 When we blur an image, we make the color transition from one side of an edge in the image to another
 smooth rather than sudden. The effect is to average out rapid changes in pixel intensity. A blur is
-a very common operation we need to perform before other tasks such as 
-[thresholding]({{ page.root }}/07-thresholding). There are several different blurring functions 
+a very common operation we need to perform before other tasks such as
+[thresholding]({{ page.root }}/07-thresholding). There are several different blurring functions
 in the `skimage.filters` module, so we will focus on just one here, the *Gaussian blur*.
 
 > ## Filters
@@ -224,11 +224,11 @@ The first two parameters to `skimage.filters.gaussian()` are the image to blur,
 `image`, and a tuple defining the sigma to use in y- and x-direction,
 `(sigma, sigma)`. The third parameter `truncate` gives the radius of the kernel
 in terms of sigmas. A Gaussian function is defined from -infinity to +infinity, but
-our kernel (which must have a finite, smaller size) can only approximate the real function. 
+our kernel (which must have a finite, smaller size) can only approximate the real function.
 Therefore, we must choose a certain distance from the centre of the function where we stop
 this approximation, and set the final size of our kernel. In the above example, we set
 `truncate` to 3.5, which means the kernel size will be 2 * sigma * 3.5. For example,
-for a `sigma` of 1.0 the resulting kernel size would be 7, while for a  
+for a `sigma` of 1.0 the resulting kernel size would be 7, while for a
 `sigma` of 2.0 the kernel size would be 14. The default value for `truncate` in scikit-image is 4.0.
 
 The last parameter to `skimage.filters.gaussian()` tells skimage to interpret our image, that has three
@@ -247,7 +247,14 @@ plt.show()
 
 > ## Experimenting with sigma values (10 min)
 >
-> Try running the code above with a range of smaller and larger sigma values.
+> The size and shape of the kernel used to blur an image can have a
+> significant effect on the result of the blurring and any downstream analysis
+> carried out on the blurred image.
+> The next two exercises ask you to experiment with the sigma values of the kernel,
+> which is a good way to develop your understanding of how the choice of kernel
+> can influence the result of blurring.
+>
+> First, try running the code above with a range of smaller and larger sigma values.
 > Generally speaking, what effect does the sigma value have on the
 > blurred image?
 >
@@ -264,9 +271,9 @@ plt.show()
 
 > ## Experimenting with kernel shape (10 min - optional, not included in timing)
 >
-> Now, try running the code above with different sigmas in the y and x direction.
+> Now, what is the effect of applying an asymmetric kernel to blurring an image?
+> Try running the code above with different sigmas in the y and x direction.
 > For example, a sigma of 1.0 in the y direction, and 6.0 in the x direction.
-> What is the effect on the blurred image?
 >
 > > ## Solution
 > >
@@ -282,9 +289,18 @@ plt.show()
 > > plt.show()
 > > ~~~
 > > {: .language-python}
+> >
 > > ![Rectangular kernel blurred image](../fig/rectangle-gaussian-blurred.png)
-> > This produces a kernel that is rectangular instead of square. Notice that the image
-> > is much more blurred in the x direction than the y direction.
+> >
+> > These unequal sigma values produce a kernel that is rectangular instead of square.
+> > The result is an image that is much more blurred in the x direction than the
+> > y direction.
+> > For most use cases, a uniform blurring effect is desirable and
+> > this kind of asymmetric blurring should be avoided.
+> > However, it can be helpful in specific circumstances e.g. when noise is present in
+> > your image in a particular pattern or orientation, such as vertical lines.
+> >
+> >
 > {: .solution}
 {: .challenge}