Merge pull request #210 from quist00/pr/useRYandCX

proposed compromise for issue #78

Author: tobyhodges

_episodes/02-image-basics.md

@@ -19,7 +19,9 @@ keypoints:
 - "Digital images are represented as rectangular arrays of square pixels."
 - "Digital images use a left-hand coordinate system, with the origin in the
 upper left corner, the x-axis running to the right, and the y-axis running
-down."
+down. Some learners may prefer to think in terms of counting down rows
+for the y-axis and across columns for the x-axis.  Thus, we will make an
+effort to allow for both approaches in our lesson presentation."
 - "Most frequently, digital images use an additive RGB model, with eight bits
 for the red, green, and blue channels."
 - "skimage images are stored as multi-dimensional NumPy arrays."
@@ -288,7 +290,11 @@ print(zero)
 > Until you have worked with images for a while,
 > the most common mistake that you will make with coordinates is to forget
 > that y coordinates get larger as they go down instead of up
-> as in a normal Cartesian coordinate system.
+> as in a normal Cartesian coordinate system. Consequently, it may be helpful to think
+> in terms of counting down rows (r) for the y-axis and across columns (c) for the x-axis. This
+> can be especially helpful in cases where you need to transpose image viewer data
+> provided in *x,y* format to *y,x* format.  Thus, we will use *cx* and *ry* where appropriate
+> to help bridge these two approaches.
 {: .callout }
 
 > ## Changing Pixel Values (5 min)

_episodes/03-skimage-images.md

@@ -178,7 +178,7 @@ In this case, the `.tif` extension causes the image to be saved as a TIFF.
 > Don't forget to use `fig, ax = plt.subplots()` so you don't overwrite
 > the first image with the second.
 > Images may appear the same size in jupyter,
-> but you can see the size difference by comparing the x and y scales for each.
+> but you can see the size difference by comparing the scales for each.
 > You can also see the differnce in file storage size on disk by
 > hovering your mouse cursor over the original
 > and the new file in the jupyter file browser, using `ls -l` in your shell,
@@ -407,7 +407,7 @@ so we can use array slicing to select rectangular areas of an image.
 Then, we can save the selection as a new image, change the pixels in the image,
 and so on.
 It is important to
-remember that coordinates are specified in *(y, x)* order and that colour values
+remember that coordinates are specified in *(ry, cx)* order and that colour values
 are specified in *(r, g, b)* order when doing these manipulations.
 
 Consider this image of a whiteboard, and suppose that we want to create a
@@ -426,14 +426,14 @@ as shown in this version of the whiteboard picture:
 
 ![Whiteboard coordinates](../fig/board-coordinates.jpg)
 
-Note that the coordinates in the preceding image are specified in *(x, y)* order.
+Note that the coordinates in the preceding image are specified in *(cx, ry)* order.
 Now if our entire whiteboard image is stored as an skimage image named `image`,
 we can create a new image of the selected region with a statement like this:
 
 `clip = image[60:151, 135:481, :]`
 
-Our array slicing specifies the range of y-coordinates first, `60:151`,
-and then the range of x-coordinates, `135:481`.
+Our array slicing specifies the range of y-coordinates or rows first, `60:151`,
+and then the range of x-coordinates or columns, `135:481`.
 Note we go one beyond the maximum value in each dimension,
 so that the entire desired area is selected.
 The third part of the slice, `:`,
@@ -481,7 +481,7 @@ plt.imshow(image)
 First, we sample a single pixel's colour at a particular location of the
 image, saving it in a variable named `color`,
 which creates a 1 × 1 × 3 NumPy array with the blue, green, and red colour values
-for the pixel located at *(y = 330, x = 90)*.
+for the pixel located at *(ry = 330, cx = 90)*.
 Then, with the `img[60:151, 135:481] = color` command,
 we modify the image in the specified area.
 From a NumPy perspective,

_episodes/04-drawing.md

@@ -127,7 +127,7 @@ Here is what our constructed mask looks like:
 
 The parameters of the `rectangle()` function `(357, 44)` and `(740, 720)`,
 are the coordinates of the upper-left (`start`) and lower-right (`end`) corners
-of a rectangle in *(y, x)* order.
+of a rectangle in *(ry, cx)* order.
 The function returns the rectangle as row (`rr`) and column (`cc`) coordinate arrays.
 
 > ## Check the documentation!
@@ -169,16 +169,16 @@ The function returns the rectangle as row (`rr`) and column (`cc`) coordinate ar
 >
 > Circles can be drawn with the `skimage.draw.disk()` function,
 > which takes two parameters:
-> the (y, x) point of the centre of the circle,
+> the (ry, cx) point of the centre of the circle,
 > and the radius of the circle.
 > There is an optional `shape` parameter that can be supplied to this function.
 > It will limit the output coordinates for cases where the circle
 > dimensions exceed the ones of the image.
 >
 > Lines can be drawn with the `skimage.draw.line()` function,
 > which takes four parameters:
-> the (y, x) coordinate of one end of the line,
-> and the (y, x) coordinate of the other end of the line.
+> the (ry, cx) coordinate of one end of the line,
+> and the (ry, cx) coordinate of the other end of the line.
 >
 > Other drawing functions supported by skimage can be found in
 > [the skimage reference pages](https://scikit-image.org/docs/dev/api/skimage.draw.html?highlight=draw#module-skimage.draw).
@@ -200,7 +200,7 @@ The function returns the rectangle as row (`rr`) and column (`cc`) coordinate ar
 > > Drawing a circle:
 > >
 > > ~~~
-> > # Draw a blue circle with centre (200, 300) in (y, x) coordinates, and radius 100
+> > # Draw a blue circle with centre (200, 300) in (ry, cx) coordinates, and radius 100
 > > rr, cc = skimage.draw.disk(center=(200, 300), radius=100, shape=image.shape[0:2])
 > > image[rr, cc] = (0, 0, 255)
 > > ~~~
@@ -209,7 +209,7 @@ The function returns the rectangle as row (`rr`) and column (`cc`) coordinate ar
 > > Drawing a line:
 > >
 > > ~~~
-> > # Draw a green line from (400, 200) to (500, 700) in (y, x) coordinates
+> > # Draw a green line from (400, 200) to (500, 700) in (ry, cx) coordinates
 > > rr, cc = skimage.draw.line(r0=400, c0=200, r1=500, c1=700)
 > > image[rr, cc] = (0, 255, 0)
 > > ~~~
@@ -438,7 +438,7 @@ The resulting masked image should look like this:
 > Your task is to write some code that will produce a mask that will
 > mask out everything except for the wells.
 > To help with this, you should use the text file `data/centers.txt` that contains
-> the (x, y) coordinates of the centre of each of the 96 wells in this image.
+> the (cx, ry) coordinates of the centre of each of the 96 wells in this image.
 > You may assume that each of the wells has a radius of 16 pixels.
 >
 > Your program should produce output that looks like this:
@@ -459,11 +459,11 @@ The resulting masked image should look like this:
 > >     for line in center_file:
 > >         # ... getting the coordinates of each well...
 > >         coordinates = line.split()
-> >         x = int(coordinates[0])
-> >         y = int(coordinates[1])
+> >         cx = int(coordinates[0])
+> >         ry = int(coordinates[1])
 > >
 > >         # ... and drawing a circle on the mask
-> >         rr, cc = skimage.draw.disk(center=(y, x), radius=16, shape=image.shape[0:2])
+> >         rr, cc = skimage.draw.disk(center=(ry, cx), radius=16, shape=image.shape[0:2])
 > >         mask[rr, cc] = False
 > >
 > > # apply the mask
@@ -491,9 +491,9 @@ The resulting masked image should look like this:
 > we could produce our well plate mask without having to
 > read in the coordinates of the centres of each well.
 > Assume that the centre of the upper left well in the image is at
-> location x = 91 and y = 108, and that there are
-> 70 pixels between each centre in the x dimension and
-> 72 pixels between each centre in the y dimension.
+> location cx = 91 and ry = 108, and that there are
+> 70 pixels between each centre in the cx dimension and
+> 72 pixels between each centre in the ry dimension.
 > Each well still has a radius of 16 pixels.
 > Write a Python program that produces the same output image as in the previous challenge,
 > but *without* having to read in the `centers.txt` file.
@@ -512,28 +512,28 @@ The resulting masked image should look like this:
 > > mask = np.ones(shape=image.shape[0:2], dtype="bool")
 > >
 > > # upper left well coordinates
-> > x0 = 91
-> > y0 = 108
+> > cx0 = 91
+> > ry0 = 108
 > >
 > > # spaces between wells
-> > deltaX = 70
-> > deltaY = 72
+> > deltaCX = 70
+> > deltaRY = 72
 > >
-> > x = x0
-> > y = y0
+> > cx = cx0
+> > ry = ry0
 > >
 > > # iterate each row and column
 > > for row in range(12):
-> >     # reset x to leftmost well in the row
-> >     x = x0
+> >     # reset cx to leftmost well in the row
+> >     cx = cx0
 > >     for col in range(8):
 > >
 > >         # ... and drawing a circle on the mask
-> >         rr, cc = skimage.draw.disk(center=(y, x), radius=16, shape=image.shape[0:2])
+> >         rr, cc = skimage.draw.disk(center=(ry, cx), radius=16, shape=image.shape[0:2])
 > >         mask[rr, cc] = False
-> >         x += deltaX
+> >         cx += deltaCX
 > >     # after one complete row, move to next row
-> >     y += deltaY
+> >     ry += deltaRY
 > >
 > > # apply the mask
 > > image[mask] = 0

_episodes/06-blurring.md

@@ -257,7 +257,7 @@ blurred = skimage.filters.gaussian(
 {: .language-python}
 
 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,
+`image`, and a tuple defining the sigma to use in ry- and cx-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
@@ -311,13 +311,13 @@ plt.show()
 > ## Experimenting with kernel shape (10 min - optional, not included in timing)
 >
 > 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.
+> Try running the code above with different sigmas in the ry and cx direction.
+> For example, a sigma of 1.0 in the ry direction, and 6.0 in the cx direction.
 >
 > > ## Solution
 > >
 > > ~~~
-> > # apply Gaussian blur, with a sigma of 1.0 in the y direction, and 6.0 in the x direction
+> > # apply Gaussian blur, with a sigma of 1.0 in the ry direction, and 6.0 in the cx direction
 > > blurred = skimage.filters.gaussian(
 > >     image, sigma=(1.0, 6.0), truncate=3.5, multichannel=True
 > > )

_extras/edge-detection.md

@@ -87,7 +87,7 @@ The skimage `skimage.feature.canny()` function performs the following steps:
    is applied to remove noise from the image.
    (So if we are doing edge detection via this function,
    we should not perform our own blurring step.)
-2. Sobel edge detection is performed on both the x and y dimensions,
+2. Sobel edge detection is performed on both the cx and ry dimensions,
    to find the intensity gradients of the edges in the image.
    Sobel edge detection computes
    the derivative of a curve fitting the gradient between light and dark areas