Pygeoprocessing

------------------
* Fixing an issue with ``warp_raster`` that would round off bounding boxes
for rasters that did not fit perfectly into the target raster's provided
pixel size.
* Cautiously ``join``\ing all process pools to avoid a potential bug where a
deamonized subprocess in a process pool may still have access to a raster
but another process may require write access to it.

------------------
* Several PyGeoprocessing functions now take advantage of multiple CPU cores:

* ``raster_calculator`` uses a separate thread to calculate raster
statistics in a ``nogil`` section of Cython code. In timing with a big
rasters we saw performance improvements of about 35%.
* ``align_and_resize_raster_stack`` uses as many CPU cores, up to the number
of CPUs reported by multiprocessing.cpu_count (but no less than 1), to
process each raster warp while also accounting for the fact that
``gdal.Warp`` uses 2 cores on its own.
* ``warp_raster`` now directly uses ``gdal.Warp``'s multithreading directly.
In practice it seems to utilize two cores.
* ``convolve_2d`` attempts to use ``multiprocessing.cpu_count`` cpus to
calculate separable convolutions per block while using the main thread to
aggregate and write the result to the target raster. In practice we saw
this improve runtimes by about 50% for large rasters.
* Fixed a bug that caused some nodata values to not be treated as nodata
if there was a numerical roundoff.
* A recent GDAL upgrade (might have been 2.0?) changed the reference to
nearest neighbor interpolation from 'nearest' to 'near'. This PR changes
PyGeoprocessing to be consistent with that change.
* ``raster_calculator`` can now also take "raw" arguments in the form of a
(value, "raw") tuple. The parameter ``value`` will be passed directly to
``local_op``. Scalars are no longer a special case and need to be passed as
"raw" parameters.
* Raising ``ValueError`` in ``get_raster_info`` and ``get_vector_info`` in
cases where non-filepath non-GIS values are passed as parameters. Previously
such an error would result in an unhelpful error in the GDAL library.

------------------
* PyGeoprocessing now supports Python 2 and 3, and is tested on python 2.7
and 3.6 Testing across multiple versions is configured to be run via
``tox``.
* After testing (tox configuration included under ``tox-libcompat.ini``),
numpy requirement has been dropped to ``numpy>=1.10.0`` and scipy has been
modified to be ``scipy>=0.14.1,!=0.19.1``.
* A dependency on ``future`` has been added for compatibility between python
versions.
* Fixed a crash in ``pygeoprocessing.routing.flow_dir_mfd`` and
``flow_dir_d8`` if a base raster was passed in that did not have a power of
two blocksize.
* ``raster_calculator`` can now take numpy arrays and scalar values along with
raster path band tuples. Arrays and scalars are broadcast to the raster size
according to numpy array broadcasting rules.
* ``align_and_resize_raster_stack`` can now take a desired target projection
which causes all input rasters to be warped to that projection on output.

------------------
* Hotfix patch to remove upper bound on required numpy version. This was
causing a conflict with InVEST's looser requirement. Requirement is now
set to >=1.13.0.

------------------
* This release marks a feature-complete version of PyGeoprocessing with a
full suite of routing and geoprocessing capabilities.
* ``pygeoprocessing.routing`` module has a ``flow_dir_mfd`` function that
calculates a 32 bit multiple flow direction raster.
* ``pygeoprocessing.routing`` module has a ``flow_accumulation_mfd`` function
that uses the flow direction raster from
``pygeoprocessing.routing.flow_dir_mfd`` to calculate a per-pixel continuous
flow accumulation raster.
* ``pygeoprocessing.routing`` module has a ``distance_to_channel_mfd``
function that calculates distance to a channel raster given a
pygeoprocessing MFD raster.
* ``pygeoprocessing.routing`` module has a ``distance_to_channel_d8`` function
that calculates distance to a channel raster given a pygeoprocessing D8
raster.

------------------
* Versioning is now handled by ``setuptools_scm`` rather than
``natcap.versioner``. ``pygeoprocessing.__version__`` is now fetched from
the package metadata.
* Raster creation defaults now set "COMPRESS=LZW" for all rasters created in
PyGeoprocessing, including internal temporary rasters. This option was
chosen after profiling large raster creation runs on platter hard drives.
In many cases processing time was dominated by several orders of magnitude
as a write-to-disk. When compression is turned on overall runtime of very
large rasters is significantly reduced. Note this otherwise increases the
runtime small raster creation and processing by a small amount.
* ``pygeoprocessing.routing`` module now has a ``fill_pits``, function which
fills hydrological pits with a focus on runtime efficiency, memory space
efficiency, and cache locality.
* ``pygeoprocessing.routing`` module has a ``flow_dir_d8`` that uses largest
slope to determine the downhill flow direction.
* ``pygeoprocessing.routing`` module has a ``flow_accumulation_d8`` that uses
a pygeoprocessing D8 flow direction raster to calculate per-pixel flow
accumulation.
* Added a ``merge_rasters`` function to ``pygeoprocessing`` that will mosaic a
set of rasters in the same projection, pixel size, and band count.