center->centre

Author: tobyhodges

episodes/02-image-basics.md

@@ -211,9 +211,9 @@ groups of pixels.
 First let's load another copy of our eight, and then make it look like a zero.
 
 To make it look like a zero,
-we need to change the number underlying the center most pixel to be 1.
+we need to change the number underlying the centremost pixel to be 1.
 With the help of those row and column headers,
-at this small scale we can determine the center pixel is in row labeled 2 and
+at this small scale we can determine the centre pixel is in row labeled 2 and
 column labeled 1.
 Using array slicing, we can then address and assign a new value to that position.
 

episodes/03-skimage-images.md

@@ -364,6 +364,7 @@ because using floating point numbers is numerically more stable.
 > e.g. you will encounter an error if you try to run `skimage.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`.
 {: .callout }
 
 ~~~

episodes/04-drawing.md

@@ -169,7 +169,7 @@ 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 center of the circle,
+> the (y, x) 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
@@ -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 center of each of the 96 wells in this image.
+> the (x, y) 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:
@@ -483,17 +483,17 @@ The resulting masked image should look like this:
 >
 > If you spent some time looking at the contents of
 > the `data/centers.txt` file from the previous challenge,
-> you may have noticed that the centers of each well in the image are very regular.
+> you may have noticed that the centres of each well in the image are very regular.
 > *Assuming* that the images are scanned in such a way that
 > the wells are always in the same place,
 > and that the image is perfectly oriented
 > (i.e., it does not slant one way or another),
 > we could produce our well plate mask without having to
-> read in the coordinates of the centers of each well.
-> Assume that the center of the upper left well in the image is at
+> 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 center in the x dimension and
-> 72 pixels between each center in the y dimension.
+> 70 pixels between each centre in the x dimension and
+> 72 pixels between each centre in the y 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.

episodes/05-creating-histograms.md

@@ -391,7 +391,7 @@ Finally we label our axes and display the histogram, shown here:
 > specifically, the seventh well from the left in the topmost row,
 > which shows Erythrosin B reacting with water.
 >
-> Hover over the image with your mouse to find the center of that well
+> Hover over the image with your mouse to find the centre of that well
 > and the radius (in pixels) of the well.
 > Then create a circular mask to select only the desired well.
 > Then, use that mask to apply the colour histogram operation to that well.

episodes/06-blurring.md

@@ -106,14 +106,14 @@ The *kernel* is another group of pixels (a separate matrix / small image),
 of the same dimensions as the rectangular group of pixels in the image,
 that moves along with the pixel being worked on by the filter.
 The width and height of the kernel must be an odd number,
-so that the pixel being worked on is always in its center.
+so that the pixel being worked on is always in its centre.
 In the example shown above, the kernel is square, with a dimension of seven pixels.
 
 To apply the kernel to the current pixel,
 an average of the the colour values of the pixels surrounding it is calculated,
 weighted by the values in the kernel.
-In a Gaussian blur, the pixels nearest the center of the kernel are
-given more weight than those far away from the center.
+In a Gaussian blur, the pixels nearest the centre of the kernel are
+given more weight than those far away from the centre.
 This averaging is done on a channel-by-channel basis,
 and the average channel values become the new value for the pixel in
 the filtered image.
@@ -128,7 +128,7 @@ consider this plot of the two-dimensional Gaussian function:
 Imagine that plot laid over the kernel for the Gaussian blur filter.
 The height of the plot corresponds to the weight given to the underlying pixel
 in the kernel.
-I.e., the pixels close to the center become more important to
+I.e., the pixels close to the centre become more important to
 the filtered pixel colour than the pixels close to the outer limits of the kernel.
 The shape of the Gaussian function is controlled via its standard deviation,
 or sigma.
@@ -143,16 +143,16 @@ of the cat image above:
 
 ![Image corner pixels](../fig/cat-corner-blue.png)
 
-The filter is going to determine the new blue channel value for the center
+The filter is going to determine the new blue channel value for the centre
 pixel -- the one that currently has the value 86. The filter calculates a
 weighted average of all the blue channel values in the kernel
-giving higher weight to the pixels near the center of the
+giving higher weight to the pixels near the centre of the
 kernel.
 
 ![Image multiplication](../fig/combination.png)
 
 This weighted average, the sum of the multiplications,
-becomes the new value for the center pixel (3, 3).
+becomes the new value for the centre pixel (3, 3).
 The same process would be used to determine the green and red channel values,
 and then the kernel would be moved over to apply the filter to the
 next pixel in the image.

episodes/08-connected-components.md

@@ -71,7 +71,8 @@ In order to understand pixel neighborhoods
 we will introduce the concept of "jumps" between pixels.
 The jumps follow two rules:
 First rule is that one jump is only allowed along the column, or the row.
-Diagonal jumps are not allowed. So, from a center pixel, denoted with `o`,
+Diagonal jumps are not allowed.
+So, from a centre pixel, denoted with `o`,
 only the pixels indicated with an `x` are reachable:
 
 ~~~
@@ -103,7 +104,7 @@ in both row and column direction.
 
 All pixels reachable with one, or two jumps form the __2-jump__ neighborhood.
 The grid below illustrates the pixels reachable from
-the center pixel `o` with a single jump, highlighted with a `1`,
+the centre pixel `o` with a single jump, highlighted with a `1`,
 and the pixels reachable with 2 jumps with a `2`.
 
 ~~~