Doc fixes as per Rick's proofreading.

Author: lossyrob

overviews/datatypes.md

@@ -19,15 +19,15 @@ GeoTrellis currently supports six basic types of raster data:
 
 The size (in bits) represents the amount of data used on the filesystem or in
 memory by each cell. Raster sizes can usually be estimated by the following
-equation:
+equations:
 
     bits = rows * columns * size-per-cell
     bytes = bits / 8
     megabytes = bytes / 1,048,576
 
 Using this formula, a 3000 x 2000 raster of boolean cells would use 750K, but a
-1000 x 1000 double raster would require 64M of space (each double value
-requires 512 times as much space as a boolean).
+1000 x 1000 double raster would require 8M of space (each double value
+requires 64 times as much space as a boolean).
 
 #### Calculation Types
 
@@ -40,7 +40,7 @@ desired, manual conversions to a wider type can be performed.
 
 Some calculations will use the raster's underlying type while others will
 specify a particular type. For instance, bitwise operations will always occur
-on a cell's integer value.
+on a cell's integer value. So if you do a bitwise operation on a floating point valued Raster, those values will be converted to integers as the operation retrieves values from the Raster.
 
 #### Conversions Between Types
 
@@ -55,7 +55,7 @@ optimizes these conversions by performing them lazily. For instance:
     // Apply conversion to Double.
     val converted = raster.convert(TypeDouble)
 
-    // No data has been not converted yet;
+    // No data has been converted yet;
     // future operations will apply conversion.
 
     // result contains Double values.

overviews/parallel.md

@@ -17,7 +17,7 @@ resources allow).
 
 If working with a single large data set (e.g. a large raster), it is usually
 beneficial to transform the raster into a tiled raster which allows the system
-to parallelize the work and to reduce I/O.
+to parallelize the work and to reduce I/O. For more on Tiled Rasters, [see the overview on the subject]({{ site.baseurl }}/overviews/tiledrasters.html).
 
 #### Distributed Execution
 With a single command, an operation can be transformed into a RemoteOperation

overviews/rendering.md

@@ -20,7 +20,7 @@ represents counts, measurements, or ratios, there are usually many distinct
 values.  One common way to represent raster data visually on a map
 is to divide up the values of the data into different categories called classes,
 and then represent each class on the map with its own color.  Each class has
-an lower and upper limit that defines what values falls within it.  For example,
+a lower and upper limit that define what values fall within it.  For example,
 a class might contain values between 0 and 10.  We call these limits *class breaks*.
 
 When rendering a raster in GeoTrellis, you can either use one of the automated classification schemes or manually determine the class breaks.  For example, if you were creating a map of average household income, you might want one of the classes to be defined as below the federal poverty guidelines (manual classification) or organized into several equal intervals between the minimum and maximum (using the built-in linear breaks classification scheme).
@@ -37,7 +37,7 @@ ranges will have a bigger difference between the low and high limits.  This
 classification scheme is particularly good at emphasizing highlights or hotspots
 where values are particularly high or low.
 
-You can also request linear breaks (or "equal interval" breaks).  Linear breaks simply divides up the values between the lowest value and the
+You can also request linear breaks (or "equal interval" breaks).  Linear breaks simply divide up the values between the lowest value and the
 highest value, with the difference between the low and high limit being the
 same for each class.  For example, if we want 5 linear breaks between 0 and 50,
 the classes would be 0-10, 10-20, 20-30, 30-40, and 40-50.

overviews/thecatalog.md

@@ -20,10 +20,10 @@ num: 2
       ]
     }
 
-GeoTrellis needs to know where to find data in order to perform it's magic. One way you can tell GeoTrellis where to find rasters is to use the [io.LoadFile operation](http://geotrellis.github.io/scaladocs/0.8/#geotrellis.io.LoadFile). Another way is to create a .json file called a *catalog*. This file tells the GeoTrellis system how to find Rasters that are referred to by name. The raster's name is declared in the [.json metadata file for the ARG as the 'layer' attribute](https://github.com/geotrellis/geotrellis/blob/0.8.1/src/test/resources/sbn/SBN_co_phila.json#L7). Any arg file that is contained in a Data Store declared by the catalog is available to be loaded by GeoTrellis through the [io.LoadRaster](http://geotrellis.github.io/scaladocs/0.8/#geotrellis.io.LoadRaster) operation. 
+GeoTrellis needs to know where to find data in order to perform its magic. One way you can tell GeoTrellis where to find Rasters is to use the [io.LoadFile operation](http://geotrellis.github.io/scaladocs/0.8/#geotrellis.io.LoadFile). Another way is to create a .json file called a *catalog*. This file tells the GeoTrellis system how to find Rasters that are referred to by name. The Raster's name is declared in the [.json metadata file for the ARG as the 'layer' attribute](https://github.com/geotrellis/geotrellis/blob/0.8.1/src/test/resources/sbn/SBN_co_phila.json#L7). Any arg file that is contained in a Data Store declared by the catalog is available to be loaded by GeoTrellis through the [io.LoadRaster](http://geotrellis.github.io/scaladocs/0.8/#geotrellis.io.LoadRaster) operation. 
 
 To let the GeoTrellis server know where to find the catalog, set the ```geotrellis.catalog``` setting in the application.conf
 
 #### Why use a Catalog?
 
-Using the Raster's name to load it into GeoTrellis allows for flexibility in the file storage of your raster data. Code that can run on one set of data can be moved to work with another set, just by changing where the catalog is pointing. Also, using a simple name to refer to raster layers allows for REST calls to include the layer name in query parameters. This lets the client be able to easily declare what server side data to operate on. If you're making a web map that has multiple raster layers, you can dynamically make calls out to GeoTrellis on any one or all the layers by passing through the name of the rasters. For an example of this, see the [admin tool's WMS call](https://github.com/geotrellis/geotrellis/blob/0.8.1/server/src/main/scala/geotrellis/admin/services/Layer.scala#L44).
+Using the Raster's name to load it into GeoTrellis allows for flexibility in the file storage of your Raster data. Code that can run on one set of data can be moved to work with another set, just by changing where the catalog is pointing. Also, using a simple name to refer to Raster layers allows for REST calls to include the layer name in query parameters. This allows the client to easily declare what server side data to operate on. If you're making a web map that has multiple Raster layers, you can dynamically make calls out to GeoTrellis on any one or all the layers by passing through the name of the Rasters. For an example of this, see the [admin tool's WMS call](https://github.com/geotrellis/geotrellis/blob/0.8.1/server/src/main/scala/geotrellis/admin/services/Layer.scala#L44).

overviews/tiledrasters.md

@@ -24,18 +24,16 @@ raster could be divided into 100 smaller rasters that are 1k by 1k cells each.
 You can think about a tiled raster as a distributed data source, as we cannot
 assume we can load the entire dataset in memory at any one time.
 
-At the current stage of development, using tiled rasters in GeoTrellis does
-unfortunately require specialized data processing and programming.  One reason
-this is the case it is far faster to operate on arrays in memory when possible.
+At the current stage of development, using tiled rasters in GeoTrellis requires special case data processing and programming.  Operations were originally designed to operate on arrays in memory, as this is the fastest access method to raster values. Tiled Rasters need to have their data retrieved in a different method.
 As we approach GeoTrellis 1.0, we hope to make the process more transparent for 
 simple models.  But while there is still much work to be done, there is useful
 infrastructure in place for developing services that operate on tiled raster
-sets.  As this functinality is still a work in progress, I'll mention plans
+sets.  As this functionality is still a work in progress, I'll mention plans
 for future development alongside the current functionality.
 
 ## The tiled ARG format 
 
-On disk, a tiled ARG is a directory full of individual ARG files (each with their own json metadata) with a single master metadata file.  If a tile is entirely
+On disk, a tiled ARG is a directory full of individual ARG files (each with its own json metadata) with a single master metadata file.  If a tile is entirely
 NoData (every cell has no value), there will be no data file for that tile.  In the future, we will support this same functionality for tiles with a
 single value.  The filename of each tile has a suffix with the row and column of the tile.  Each
 tile has the same width in pixels and the same height in pixels: for example,
@@ -61,11 +59,12 @@ you create 1000x1000 tiles, the tiles on the right and bottom edge will have
 For creating the tile, you should use the "import-tile" gt-tool task.
 
 The options for gt-tool are:
-  -i  Path of the input raster file (which can be geotiff, ARG, or another GDAL supported raster format)
-  -d  Output directory for tiles
-  -n  Name of the output raster
-  -cols  Pixel columns (pixel width) per tile
-  -rows  Pixel rows (pixel height) per tile
+
+* -i  Path of the input raster file (which can be geotiff, ARG, or another GDAL supported raster format)
+* -d  Output directory for tiles
+* -n  Name of the output raster
+* -cols  Pixel columns (pixel width) per tile
+* -rows  Pixel rows (pixel height) per tile
 
 For example, a sample usage could look like:
 
@@ -114,7 +113,7 @@ have been implemented to handle tiled rasters.
 ## Map/Reduce style Summary operations
 
 As designed, a core function of tiled rasters is to allow operations on rasters too large to fit in memory.
-The logic.TileReducer class be extended to create operations that perform an operation on each individual
+The logic.TileReducer class can be extended to create operations that perform an operation on each individual
 tile (the mapper) and then perform an operation to combine the results of those operations (the reducer).
 Examples of operations that implement this interface are stats.Min and stats.GetHistogram.
 
@@ -125,7 +124,9 @@ a single compound operation that is only run when necessary.  Because of this, i
 local operations as part of your tiled raster operations.  However, you should not *only* use local
 operations on a tiled raster as you cannot assume that the raster can fit into memory on a single
 machine to produce a result.  For example, you might summarize the results of your raster transformed
-by local operations. 
+by local operations.
+
+For maximum efficiency it's important that a sequence of local raster operations on a tile can be completed using a machine's available memory. GeoTrellis helps by performing local operations lazily, combining chained local operations into a single compound operation executed on a pixel at a time (rather than constructing an intermediate raster for each operation). However, many operations have results that are Rasters held completely in memory. The operation might still exceed available memory if the final result is a in-memory raster that is larger than can fit in memory. Adding a summarizing operation as the final step can prevent the need to keep an entire raster tile in memory.
 
 ### Focal operations
 

overviews/vector.md

@@ -33,7 +33,7 @@ the context of an operation
 #### Working with Extents as Vectors
 
 When working with data it can often be useful to perform vector
-operations on extents. One very common operations is buffered a given
+operations on extents. One very common operation is buffering a given
 extent to make sure that data isn't being clipped
 
     val extent:Op[Extent] = ParseExtent(extentParam)
@@ -47,7 +47,7 @@ extent to make sure that data isn't being clipped
 #### Creating Your Own Vector Operations
 
 If an operation that you want to use isn't yet exposed by the GeoTrellis
-API adding a new one is as simple as extending and operation class:
+API adding a new one is as simple as extending an operation class:
 
     case class GetInteriorPoint[A](g: Geometry[A])
         extends Op1[Geometry[A], Point[A](geom =>

tutorials/index.md

@@ -7,7 +7,7 @@ num: 1
 outof: 4
 ---
 
-To the right is a list of tutorials that will help you set learn to use GeoTrellis effectively through guided usage. We will be adding to these tutorials, so make sure to visit often!
+To the right is a list of tutorials that will help you learn to use GeoTrellis effectively through guided usage. We will be adding to these tutorials, so make sure to visit often!
 
 The following blog articles are also great introductions to using GeoTrellis:
 * [Developing a Kernel Density Service With GeoTrellis](http://www.azavea.com/blogs/labs/2013/03/developing-a-kernel-density-service-with-geotrellis/)

tutorials/webservice.md

@@ -9,6 +9,10 @@ num: 3
 In this tutorial we will walk through building web services 
 using Jetty and GeoTrellis from scratch.
 
+#### Scala
+
+GeoTrellis is a scala library, so we will be using Scala to build up our web service. If you are unfamiliar with Scala, you can learn more about the language [here](http://www.scala-lang.org/).
+
 #### Setting up the project
 
 We'll be using [sbt](http://www.scala-sbt.org/) as our build tool. The GeoTrellis code base
@@ -117,11 +121,11 @@ which Jetty then marshals back to the client.
 #### The GeoTrellis Server
 
 Throughout the rest of the tutorial, we will be using GeoTrellis operations to 
-service the requests. GeoTrellis defines [operations](http://localhost:4000/operations/) 
+service the requests. GeoTrellis defines [operations]({{ site.baseurl }}/operations/) 
 that work with vector and raster geospatial data, as well as more simple types such as strings and integers.
 An operation is constructed in code before it is actually executed. This allows
 operations to be composed in a way where their execution happens only when needed.
-This also allows for optimization and parrallization to occur in the execution
+This also allows for optimization and parallelization to occur in the execution
 of composed operations.
 
 The way to execute operations is to run them with a GeoTrellis `Server` object.
@@ -166,7 +170,7 @@ data now by creating a directory in the root direcotry called `data` and create
     }
 
 This catalog defines one data store, which is the directory `data/arg`. This means any raster in ARG format 
-found in that directory will be available to the Server. Note that a data store cannot be the same directory
+found in that directory will be available to the Server. For a description of the ARG format, see the [documentation on loading data]({{ site.baseurl }}/gettingstarted/data.html). Note that a data store cannot be the same directory
 as the catalog.json lives, because the Server will consider any JSON file in a data store directory to be a
 layer definition for an ARG file.
 
@@ -304,7 +308,7 @@ will result in `0,-10,15,10`.
 
 It's now time to work with some raster data. Download the 
 [sample data set]({{ site.baseurl }}/data/tutorial.tar.gz)
-and extract it's contents into the `data/arg` folder. Now when we restart
+and extract its contents into the `data/arg` folder. Now when we restart
 the tutorial server, the Main.server will have access to a raster named
 `philly_inc_percap`. This a byte-valued raster containing data values representing
 income per capita for the city of Philadelphia. This raster is in 
@@ -362,12 +366,12 @@ Now restart the server, and see the raster:
 `http://localhost:8888/simpleDraw`
 
 Given a `name`, the `io.LoadRaster` operation will return a `geotrellis.Raster`
-instance containing the raster data who's layer name is the parameter. The server
+instance containing the raster data whose layer name is the parameter. The server
 can find this raster by name because of the setup with the Catalog we did earlier.
 
 `SimpleRenderPng` takes in a raster and a color ramp. Color ramps have been
 chosen by the designers at Azavea to handle representing common raster visualization 
-use cases in an esteticly pleasing and informative way. You can see the different color ramps available in our 
+use cases in an aesthetically pleasing and informative way. You can see the different color ramps available in our 
 [Color Documentation]( {{ site.baseurl }}/overviews/rendering.html).
 The `SimpleRenderPng` operation returns a Byte Array which contains the raw PNG file. To return
 this to the browser, we just return the data with the MIME type `image/png`.