Little tweaks to wording and code style for nodata page

Signed-off-by: Jason T. Brown <[email protected]>

Author: vpipkt

pyrasterframes/src/main/python/docs/nodata-handling.pymd

@@ -148,7 +148,7 @@ display(sample[1])
 
 ## NoData and Local Arithmatic
 
-Let's now explore how the presence of NoData affects local arithmatic operations. To demonstrate the behaviour, lets create two tiles. One tile will have values of 0 and 1, and the other will have values of just 0. 
+Let's now explore how the presence of NoData affects @ref:[local map algebra](local-algebra.md) operations. To demonstrate the behaviour, lets create two tiles. One tile will have values of 0 and 1, and the other will have values of just 0. 
 
 
 ```python
@@ -161,27 +161,34 @@ y = Tile(np.zeros((tile_size, tile_size), dtype='int16'))
 rf = spark.createDataFrame([Row(x=x, y=y)])
 print('x')
 display(x)
+```
+
+```python
 print('y')
 display(y)
 ```
 
-Now, let's create a new column from `x` with the value of 1 changed to NoData. Then, we will add this new column with NoData to the `y` column. As shown below, the result of the sum also has NoData (represented in white). In general for arithmatic operations, Data + NoData = NoData. To see more information about possible operations on Tile columns, see the @ref:[local map algebra](local-algebra.md) doc.
+Now, let's create a new column from `x` with the value of 1 changed to NoData. Then, we will add this new column with NoData to the `y` column. As shown below, the result of the sum also has NoData (represented in white). In general for local algebra operations, Data + NoData = NoData. 
 
 ```python
 masked_rf = rf.withColumn('x_nd', rf_mask_by_value('x', 'x', lit(1)) )
 masked_rf = masked_rf.withColumn('x_nd_y_sum', rf_local_add('x_nd', 'y'))
 row = masked_rf.collect()[0]
 print('x with NoData')
 display(row.x_nd)
-print('x with NoData and y sum')
+```
+
+```python
+print('x with NoData plus y')
 display(row.x_nd_y_sum)
 ```
+To see more information about possible operations on Tile columns, see the @ref:[local map algebra](local-algebra.md) page and @ref:[function reference](reference.md#local-map-algebra).
 
 ## Changing a Tile's NoData Values
 
-One way to mask a tile is to make a new tile with a user defined NoData value. We will explore this method below. First, lets create a rasterframe from a tile with values of 0, 1, 2, and 3. We will use numpy to create a 100x100 Tile with columns of 0, 1, 2, and 3.
+One way to mask a tile is to make a new tile with a user defined NoData value. We will explore this method below. First, lets create a DataFrame from a tile with values of 0, 1, 2, and 3. We will use numpy to create a 100x100 Tile with vertical bands containing values 0, 1, 2, and 3.
 
-```python create_dummy_tile
+```python create_dummy_tile, caption='Dummy Tile'
 tile_size = 100
 x = np.zeros((tile_size, tile_size), dtype='int16')
 
@@ -225,7 +232,7 @@ display(collected[0].tile_nd_2)
 
 ## Combining Tiles with Different Data Types
 
-RasterFrames supports having Tile columns with multiple cell types in a single RasterFrame. It is important to understand how these different cell types interact. 
+RasterFrames supports having Tile columns with multiple cell types in a single DataFrame. It is important to understand how these different cell types interact. 
 
 Let's first create a RasterFrame that has columns of `float` and `int` cell type. 
 
@@ -234,24 +241,25 @@ x = Tile((np.ones((100, 100))*2).astype('float'))
 y = Tile((np.ones((100, 100))*3.0).astype('int32'))
 rf = spark.createDataFrame([Row(x=x, y=y)])
 
-rf.select(rf_cell_type('y'), rf_cell_type('x')).distinct().show()
+rf.select(rf_cell_type('x'), rf_cell_type('y')).distinct().show()
 ```
 
-When performing a local operation between tile columns with cell types `int` and type `float`, the resulting tile cell type will be `float`. If two tiles of different sized integer cell types are added together in the same way, the resulting cell type will be the same as the largest of the two integer cell types.
+When performing a local operation between tile columns with cell types `int` and type `float`, the resulting tile cell type will be `float`. In local algebra over two tiles of different "sized" cell types, the resulting cell type will be the largest of the two input tiles' cell types.
 
 ```python
-rf_added = rf.withColumn('xy_sum', rf_local_add('y', 'x'))
-rf_added.select(rf_cell_type('xy_sum'), rf_cell_type('y'), rf_cell_type('x')).distinct().show()
+rf.select(
+    rf_cell_type('x'), 
+    rf_cell_type('y'),
+    rf_cell_type(rf_local_add('x', 'y').alias('xy_sum')), 
+    ).show(1)
 ```
 
 Combining tile columns of different cell types gets a little trickier when user defined NoData cell types are involved. Let's create 2 tile columns: one with a NoData value of 1, and one with a NoData value of 2.
 
 ```python
-x = Tile((np.ones((100, 100))*3).astype('int16'))
-rf = spark.createDataFrame([Row(x=x)])
-
-rf_nd = rf.withColumn('x_nd_1', rf_convert_cell_type('x', get_nodata_ct(1))) \
-          .withColumn('x_nd_2', rf_convert_cell_type('x', get_nodata_ct(2)))
+x_nd_1 = Tile((np.ones((100, 100))*3), get_nodata_ct(1))
+x_nd_2 = Tile((np.ones((100, 100))*3), get_nodata_ct(2))
+rf_nd = spark.createDataFrame([Row(x_nd_1=x_nd_1, x_nd_2=x_nd_2)])
 ```
 
 Let's try adding the tile columns with different NoData values. When there is an inconsistent NoData value in the two columns, the NoData value of the right-hand side of the sum is kept. In this case, this means the result has a NoData value of 1. 
@@ -268,9 +276,9 @@ rf_nd_sum = rf_nd.withColumn('x_nd_sum', rf_local_add('x_nd_1', 'x_nd_2'))
 rf_nd_sum.select(rf_cell_type('x_nd_sum')).distinct().show()
 ```
 
-## Nodata Values in Aggregation
+## NoData Values in Aggregation
 
-Let's use the same tile as before to demonstrate how NoData values affect tile aggregations
+Let's use the same tile as before to demonstrate how NoData values affect tile aggregations.
 
 ```python
 tile_size = 100