markdown source builds

Auto-generated via {sandpaper}
Source  : 0c29d28
Branch  : main
Author  : Toby Hodges <tbyhdgs@gmail.com>
Time    : 2023-09-05 08:21:04 +0000
Message : Merge pull request #299 from mkcor/new-import-ski

Use new import convention for scikit-image.

Author: actions-user

02-image-basics.md

@@ -84,11 +84,11 @@ First, the necessary imports:
 ```python
 """Python libraries for learning and performing image processing."""
 
-import numpy as np
-import matplotlib.pyplot as plt
-import ipympl
 import imageio.v3 as iio
-import skimage
+import ipympl
+import matplotlib.pyplot as plt
+import numpy as np
+import skimage as ski
 ```
 
 The `v3` module of imageio (`imageio.v3`) is imported as `iio`. This module
@@ -112,7 +112,7 @@ You will encounter several different forms of `import` statement.
 import skimage                 # form 1, load whole skimage library
 import skimage.draw            # form 2, load skimage.draw module only
 from skimage.draw import disk  # form 3, load only the disk function
-import numpy as np             # form 4, load all of numpy into an object called np
+import skimage as ski          # form 4, load all of skimage into an object called ski
 ```
 
 ::::::::::::::  solution
@@ -126,18 +126,14 @@ e.g., to access the `disk` function used in [the drawing episode](04-drawing.md)
 you would write `skimage.draw.disk()`.
 
 Form 2 loads only the `draw` module of `skimage` into the program.
-When we run the code,
-the program will take less time and use less memory
-because we will not load the whole scikit-image library.
 The syntax needed to use the module remains unchanged:
 to access the `disk` function,
 we would use the same function call as given for form 1.
 
-To further reduce the time and memory requirements for your program,
-form 3 can be used to import only a specific function/class from a library/module.
+Form 3 can be used to import only a specific function/class from a library/module.
 Unlike the other forms, when this approach is used,
 the imported function or class can be called by its name only,
-without prefixing it with the name of the module/library from which it was loaded,
+without prefixing it with the name of the library/module from which it was loaded,
 i.e., `disk()` instead of `skimage.draw.disk()` using the example above.
 One hazard of this form is that importing like this will overwrite any
 object with the same name that was defined/imported earlier in the program,
@@ -148,7 +144,7 @@ Finally, the `as` keyword can be used when importing,
 to define a name to be used as shorthand for the library/module being imported.
 This name is referred to as an alias. Typically, using an alias (such as
 `np` for the NumPy library) saves us a little typing.
-You may see `as` combined with any of the other first three forms of `import` statement.
+You may see `as` combined with any of the other first three forms of `import` statements.
 
 Which form is used often depends on
 the size and number of additional tools being loaded into the program.

03-skimage-images.md

@@ -26,14 +26,11 @@ for accessing and changing digital images.
 ## First, import the packages needed for this episode
 
 ```python
-import numpy as np
-import matplotlib.pyplot as plt
-import ipympl
 import imageio.v3 as iio
-import skimage
-import skimage.color
-import skimage.transform
-import skimage.util
+import ipympl
+import matplotlib.pyplot as plt
+import numpy as np
+import skimage as ski
 ```
 
 ## Reading, displaying, and saving images
@@ -146,19 +143,18 @@ functions we will cover in this workshop.
 
 ## Resizing an image (10 min)
 
-Add `import skimage.transform` and `import skimage.util` to your list of imports.
 Using the `chair.jpg` image located in the data folder,
 write a Python script to read your image into a variable named `chair`.
 Then, resize the image to 10 percent of its current size using these lines of code:
 
 ```python
 new_shape = (chair.shape[0] // 10, chair.shape[1] // 10, chair.shape[2])
-resized_chair = skimage.transform.resize(image=chair, output_shape=new_shape)
-resized_chair = skimage.util.img_as_ubyte(resized_chair)
+resized_chair = ski.transform.resize(image=chair, output_shape=new_shape)
+resized_chair = ski.util.img_as_ubyte(resized_chair)
 ```
 
 As it is used here,
-the parameters to the `skimage.transform.resize()` function are
+the parameters to the `ski.transform.resize()` function are
 the image to transform, `chair`,
 the dimensions we want the new image to have, `new_shape`.
 
@@ -168,7 +164,7 @@ Note that the pixel values in the new image are an approximation of
 the original values and should not be confused with actual, observed
 data. This is because scikit-image interpolates the pixel values when
 reducing or increasing the size of an
-image. `skimage.transform.resize` has a number of optional
+image. `ski.transform.resize` has a number of optional
 parameters that allow the user to control this interpolation. You
 can find more details in the [scikit-image
 documentation](https://scikit-image.org/docs/stable/api/skimage.transform.html#skimage.transform.resize).
@@ -178,7 +174,7 @@ documentation](https://scikit-image.org/docs/stable/api/skimage.transform.html#s
 Image files on disk are normally stored as whole numbers for space efficiency,
 but transformations and other math operations often result in
 conversion to floating point numbers.
-Using the `skimage.util.img_as_ubyte()` method converts it back to whole numbers
+Using the `ski.util.img_as_ubyte()` method converts it back to whole numbers
 before we save it back to disk.
 If we don't convert it before saving,
 `iio.imwrite()` may not recognise it as image data.
@@ -210,8 +206,8 @@ chair = iio.imread(uri="data/chair.jpg")
 
 # resize the image
 new_shape = (chair.shape[0] // 10, chair.shape[1] // 10, chair.shape[2])
-resized_chair = skimage.transform.resize(image=chair, output_shape=new_shape)
-resized_chair = skimage.util.img_as_ubyte(resized_chair)
+resized_chair = ski.transform.resize(image=chair, output_shape=new_shape)
+resized_chair = ski.util.img_as_ubyte(resized_chair)
 
 # write out image
 iio.imwrite(uri="data/resized_chair.jpg", image=resized_chair)
@@ -301,12 +297,12 @@ the result is an image in which the extraneous background detail has been remove
 
 It is often easier to work with grayscale images, which have a single channel,
 instead of colour images, which have three channels.
-scikit-image offers the function `skimage.color.rgb2gray()` to achieve this.
+scikit-image offers the function `ski.color.rgb2gray()` to achieve this.
 This function adds up the three colour channels in a way that matches
 human colour perception,
 see [the scikit-image documentation for details](https://scikit-image.org/docs/dev/api/skimage.color.html#skimage.color.rgb2gray).
 It returns a grayscale image with floating point values in the range from 0 to 1.
-We can use the function `skimage.util.img_as_ubyte()` in order to convert it back to the
+We can use the function `ski.util.img_as_ubyte()` in order to convert it back to the
 original data type and the data range back 0 to 255.
 Note that it is often better to use image values represented by floating point values,
 because using floating point numbers is numerically more stable.
@@ -320,7 +316,7 @@ which is why we use "colour" in the explanatory text of this lesson.
 However, scikit-image contains many modules and functions that include
 the US English spelling, `color`.
 The exact spelling matters here,
-e.g. you will encounter an error if you try to run `skimage.colour.rgb2gray()`.
+e.g. you will encounter an error if you try to run `ski.colour.rgb2gray()`.
 To account for this, we will use the US English spelling, `color`,
 in example Python code throughout the lesson.
 You will encounter a similar approach with "centre" and `center`.
@@ -338,7 +334,7 @@ fig, ax = plt.subplots()
 plt.imshow(chair)
 
 # convert to grayscale and display
-gray_chair = skimage.color.rgb2gray(chair)
+gray_chair = ski.color.rgb2gray(chair)
 fig, ax = plt.subplots()
 plt.imshow(gray_chair, cmap="gray")
 ```
@@ -576,8 +572,8 @@ iio.imwrite(uri="data/clipped_maize.jpg", image=clipped_maize)
 
 - Images are read from disk with the `iio.imread()` function.
 - We create a window that automatically scales the displayed image with Matplotlib and calling `show()` on the global figure object.
-- Colour images can be transformed to grayscale using `skimage.color.rgb2gray()` or, in many cases, be read as grayscale directly by passing the argument `mode="L"` to `iio.imread()`.
-- We can resize images with the `skimage.transform.resize()` function.
+- Colour images can be transformed to grayscale using `ski.color.rgb2gray()` or, in many cases, be read as grayscale directly by passing the argument `mode="L"` to `iio.imread()`.
+- We can resize images with the `ski.transform.resize()` function.
 - NumPy array commands, such as `image[image < 128] = 0`, can be used to manipulate the pixels of an image.
 - Array slicing can be used to extract sub-images or modify areas of images, e.g., `clip = image[60:150, 135:480, :]`.
 - Metadata is not retained when images are loaded as scikit-image images.

04-drawing.md

@@ -27,17 +27,16 @@ based on changes in colour or shape.
 ## First, import the packages needed for this episode
 
 ```python
-import numpy as np
-import matplotlib.pyplot as plt
-import ipympl
 import imageio.v3 as iio
-import skimage
-import skimage.draw
+import ipympl
+import matplotlib.pyplot as plt
+import numpy as np
+import skimage as ski
+
 %matplotlib widget
 ```
 
-Here, we import the `draw` submodule of `skimage` as well as packages familiar
-from earlier in the lesson.
+Here, we import the same packages as earlier in the lesson.
 
 ## Drawing on images
 
@@ -113,7 +112,7 @@ Next, we draw a filled, rectangle on the mask:
 
 ```python
 # Draw filled rectangle on the mask image
-rr, cc = skimage.draw.rectangle(start=(357, 44), end=(740, 720))
+rr, cc = ski.draw.rectangle(start=(357, 44), end=(740, 720))
 mask[rr, cc] = False
 
 # Display mask image
@@ -139,7 +138,7 @@ it is wise to check how the function is used, via
 or other usage examples on programming-related sites such as
 [Stack Overflow](https://stackoverflow.com/).
 Basic information about scikit-image functions can be found interactively in Python,
-via commands like `help(skimage)` or `help(skimage.draw.rectangle)`.
+via commands like `help(ski)` or `help(ski.draw.rectangle)`.
 Take notes in your lab notebook.
 And, it is always wise to run some test code to verify
 that the functions your program uses are behaving in the manner you intend.
@@ -170,21 +169,21 @@ such that it is easier for other people to understand your code.
 ## Other drawing operations (15 min)
 
 There are other functions for drawing on images,
-in addition to the `skimage.draw.rectangle()` function.
+in addition to the `ski.draw.rectangle()` function.
 We can draw circles, lines, text, and other shapes as well.
 These drawing functions may be useful later on, to help annotate images
 that our programs produce.
 Practice some of these functions here.
 
-Circles can be drawn with the `skimage.draw.disk()` function,
+Circles can be drawn with the `ski.draw.disk()` function,
 which takes two parameters:
 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,
+Lines can be drawn with the `ski.draw.line()` function,
 which takes four parameters:
 the (ry, cx) coordinate of one end of the line,
 and the (ry, cx) coordinate of the other end of the line.
@@ -215,15 +214,15 @@ Drawing a circle:
 
 ```python
 # 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=canvas.shape[0:2])
+rr, cc = ski.draw.disk(center=(200, 300), radius=100, shape=canvas.shape[0:2])
 canvas[rr, cc] = (0, 0, 255)
 ```
 
 Drawing a line:
 
 ```python
 # 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)
+rr, cc = ski.draw.line(r0=400, c0=200, r1=500, c1=700)
 canvas[rr, cc] = (0, 255, 0)
 ```
 
@@ -249,7 +248,7 @@ canvas = np.zeros(shape=(600, 800, 3), dtype="uint8")
 
 # draw a blue circle at a random location 15 times
 for i in range(15):
-    rr, cc = skimage.draw.disk(center=(
+    rr, cc = ski.draw.disk(center=(
          random.randrange(600),
          random.randrange(800)),
          radius=50,
@@ -278,7 +277,7 @@ for i in range(15):
     x = random.random()
     if x < 0.33:
         # draw a blue circle at a random location
-        rr, cc = skimage.draw.disk(center=(
+        rr, cc = ski.draw.disk(center=(
             random.randrange(600),
             random.randrange(800)),
             radius=50,
@@ -287,7 +286,7 @@ for i in range(15):
         color = (0, 0, 255)
     elif x < 0.66:
         # draw a green line at a random location
-        rr, cc = skimage.draw.line(
+        rr, cc = ski.draw.line(
             r0=random.randrange(600),
             c0=random.randrange(800),
             r1=random.randrange(600),
@@ -296,7 +295,7 @@ for i in range(15):
         color = (0, 255, 0)
     else:
         # draw a red rectangle at a random location
-        rr, cc = skimage.draw.rectangle(
+        rr, cc = ski.draw.rectangle(
             start=(random.randrange(600), random.randrange(800)),
             extent=(50, 50),
             shape=canvas.shape[0:2],
@@ -359,7 +358,7 @@ maize_seedlings = iio.imread(uri="data/maize-seedlings.tif")
 mask = np.ones(shape=maize_seedlings.shape[0:2], dtype="bool")
 
 # Draw a filled rectangle on the mask image
-rr, cc = skimage.draw.rectangle(start=(357, 44), end=(740, 720))
+rr, cc = ski.draw.rectangle(start=(357, 44), end=(740, 720))
 mask[rr, cc] = False
 ```
 
@@ -416,7 +415,7 @@ remote = np.array(remote)
 mask = np.ones(shape=remote.shape[0:2], dtype="bool")
 
 # Draw a filled rectangle on the mask image
-rr, cc = skimage.draw.rectangle(start=(93, 1107), end=(1821, 1668))
+rr, cc = ski.draw.rectangle(start=(93, 1107), end=(1821, 1668))
 mask[rr, cc] = False
 
 # Apply the mask
@@ -484,7 +483,7 @@ with open("data/centers.txt", "r") as center_file:
         ry = int(coordinates[1])
 
         # ... and drawing a circle on the mask
-        rr, cc = skimage.draw.disk(center=(ry, cx), radius=16, shape=wellplate.shape[0:2])
+        rr, cc = ski.draw.disk(center=(ry, cx), radius=16, shape=wellplate.shape[0:2])
         mask[rr, cc] = False
 
 # apply the mask
@@ -554,7 +553,7 @@ for row in range(12):
     for col in range(8):
 
         # ... and drawing a circle on the mask
-        rr, cc = skimage.draw.disk(center=(ry, cx), radius=16, shape=wellplate.shape[0:2])
+        rr, cc = ski.draw.disk(center=(ry, cx), radius=16, shape=wellplate.shape[0:2])
         mask[rr, cc] = False
         cx += deltaCX
     # after one complete row, move to next row
@@ -575,7 +574,7 @@ plt.imshow(wellplate)
 :::::::::::::::::::::::::::::::::::::::: keypoints
 
 - We can use the NumPy `zeros()` function to create a blank, black image.
-- We can draw on scikit-image images with functions such as `skimage.draw.rectangle()`, `skimage.draw.disk()`, `skimage.draw.line()`, and more.
+- We can draw on scikit-image images with functions such as `ski.draw.rectangle()`, `ski.draw.disk()`, `ski.draw.line()`, and more.
 - The drawing functions return indices to pixels that can be set directly.
 
 ::::::::::::::::::::::::::::::::::::::::::::::::::

05-creating-histograms.md

@@ -25,12 +25,12 @@ display histograms for images.
 ## First, import the packages needed for this episode
 
 ```python
-import numpy as np
-import matplotlib.pyplot as plt
-import ipympl
 import imageio.v3 as iio
-import skimage
-import skimage.draw
+import ipympl
+import matplotlib.pyplot as plt
+import numpy as np
+import skimage as ski
+
 %matplotlib widget
 ```
 
@@ -61,7 +61,7 @@ Here we load the image in grayscale instead of full colour, and display it:
 plant_seedling = iio.imread(uri="data/plant-seedling.jpg", mode="L")
 
 # convert the image to float dtype with a value range from 0 to 1
-plant_seedling = skimage.util.img_as_float(plant_seedling)
+plant_seedling = ski.util.img_as_float(plant_seedling)
 
 # display the image
 fig, ax = plt.subplots()
@@ -73,7 +73,7 @@ plt.imshow(plant_seedling, cmap="gray")
 Again, we use the `iio.imread()` function to load our image.
 Then, we convert the grayscale image of integer dtype, with 0-255 range, into
 a floating-point one with 0-1 range, by calling the function
-`skimage.util.img_as_float`.
+`ski.util.img_as_float`.
 We will keep working with images in the value range 0 to 1 in this lesson.
 
 We now use the function `np.histogram` to compute the histogram of our image
@@ -205,9 +205,9 @@ plant_seedling = iio.imread(uri="data/plant-seedling.jpg", mode="L")
 fig, ax = plt.subplots()
 plt.imshow(plant_seedling, cmap="gray")
 
-# create mask here, using np.zeros() and skimage.draw.rectangle()
+# create mask here, using np.zeros() and ski.draw.rectangle()
 mask = np.zeros(shape=plant_seedling.shape, dtype="bool")
-rr, cc = skimage.draw.rectangle(start=(199, 410), end=(384, 485))
+rr, cc = ski.draw.rectangle(start=(199, 410), end=(384, 485))
 mask[rr, cc] = True
 
 # display the mask
@@ -403,7 +403,7 @@ And, the program should produce a colour histogram that looks like this:
 ```python
 # create a circular mask to select the 7th well in the first row
 mask = np.zeros(shape=wellplate.shape[0:2], dtype="bool")
-circle = skimage.draw.disk(center=(240, 1053), radius=49, shape=wellplate.shape[0:2])
+circle = ski.draw.disk(center=(240, 1053), radius=49, shape=wellplate.shape[0:2])
 mask[circle] = 1
 
 # just for display: