This is an automated email from the git hooks/post-receive script.

johanvdw-guest pushed a commit to branch master
in repository rasterio.

commit bbdbaef4fe0479d93dba96c035f3bb61cbcb2fd0
Author: Johan Van de Wauw <johan.vandew...@gmail.com>
Date:   Mon Dec 22 23:53:39 2014 +0100

    Imported Upstream version 0.16
---
 .travis.yml             |   1 +
 AUTHORS.txt             |   1 +
 CHANGES.txt             |  12 ++-
 rasterio/__init__.py    |   3 +-
 rasterio/_base.pyx      |  22 +++--
 rasterio/_drivers.pyx   |  15 ++++
 rasterio/_features.pyx  |  10 ++-
 rasterio/_io.pyx        |  11 +++
 rasterio/_warp.pyx      |  26 ++++--
 rasterio/features.py    |  31 ++++---
 rasterio/transform.py   |  14 ++-
 rasterio/warp.py        | 140 ++++++++++++++++++++++++-----
 setup.py                |   5 +-
 tests/data/README.rst   |   6 ++
 tests/test_no_georef.py |  30 +++++++
 tests/test_read.py      |  26 ++++++
 tests/test_warp.py      | 235 ++++++++++++++++++++++++++++++++----------------
 17 files changed, 437 insertions(+), 151 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 7180aed..0fc4c5c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -8,6 +8,7 @@ before_install:
   - sudo apt-get update -qq
   - sudo apt-get install -y libgdal1h gdal-bin libgdal-dev
 install:
+  - pip install --install-option="--no-cython-compile" cython
   - "pip install -r requirements-dev.txt"
   - "pip install pytest"
   - "pip install coveralls"
diff --git a/AUTHORS.txt b/AUTHORS.txt
index 54f3fca..3cd8e34 100644
--- a/AUTHORS.txt
+++ b/AUTHORS.txt
@@ -9,5 +9,6 @@ Chrisophe Gohlke https://github.com/cgohlke
 Robin Wilson https://github.com/robintw
 Mike Toews https://github.com/mwtoews
 Amit Kapadia https://github.com/kapadia
+Alessandro Amici https://github.com/alexamici
 
 See also https://github.com/mapbox/rasterio/graphs/contributors.
diff --git a/CHANGES.txt b/CHANGES.txt
index afd760b..6830152 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,8 +1,16 @@
 Changes
 =======
 
-0.1.5.1 (2014-11-03)
---------------------
+0.16.0 (2014-12-16)
+-------------------
+- More graceful, slice-like handling of windows (#191).
+- Addition of optional z coordinate to warp.transform() (#199).
+- Relax excessively strict transform guard, allowing translation of rasters
+  with no georeferencing (#210).
+- Removal of setuptools from the package's install_requires (#222).
+
+0.15.1 (2014-11-03)
+-------------------
 - Fix incorrect use of output.dtype (#196).
 
 0.15 (2014-10-11)
diff --git a/rasterio/__init__.py b/rasterio/__init__.py
index 04c7691..4bbc8d0 100644
--- a/rasterio/__init__.py
+++ b/rasterio/__init__.py
@@ -18,7 +18,7 @@ from rasterio.transform import Affine, guard_transform
 
 __all__ = [
     'band', 'open', 'drivers', 'copy', 'pad']
-__version__ = "0.15.1"
+__version__ = "0.16"
 
 log = logging.getLogger('rasterio')
 class NullHandler(logging.Handler):
@@ -161,4 +161,3 @@ def pad(array, transform, pad_width, mode=None, **kwargs):
     padded_trans[2] -= pad_width*padded_trans[0]
     padded_trans[5] -= pad_width*padded_trans[4]
     return padded_array, Affine(*padded_trans[:6])
-
diff --git a/rasterio/_base.pyx b/rasterio/_base.pyx
index 87f696e..e529efd 100644
--- a/rasterio/_base.pyx
+++ b/rasterio/_base.pyx
@@ -511,12 +511,11 @@ cdef class DatasetReader(object):
         
         if self._hds == NULL:
           raise ValueError("can't read closed raster file")
-        if bidx > 0:
-            if bidx not in self.indexes:
-                raise ValueError("Invalid band index")
-            hBand = _gdal.GDALGetRasterBand(self._hds, bidx)
-            if hBand == NULL:
-                raise ValueError("NULL band")
+        if bidx not in self.indexes:
+            raise ValueError("Invalid band index")
+        hBand = _gdal.GDALGetRasterBand(self._hds, bidx)
+        if hBand == NULL:
+            raise ValueError("NULL band")
         value = _gdal.GDALGetRasterColorInterpretation(hBand)
         return ColorInterp(value)
     
@@ -528,12 +527,11 @@ cdef class DatasetReader(object):
         cdef _gdal.GDALColorEntry *color
         if self._hds == NULL:
             raise ValueError("can't read closed raster file")
-        if bidx > 0:
-            if bidx not in self.indexes:
-                raise ValueError("Invalid band index")
-            hBand = _gdal.GDALGetRasterBand(self._hds, bidx)
-            if hBand == NULL:
-                raise ValueError("NULL band")
+        if bidx not in self.indexes:
+            raise ValueError("Invalid band index")
+        hBand = _gdal.GDALGetRasterBand(self._hds, bidx)
+        if hBand == NULL:
+            raise ValueError("NULL band")
         hTable = _gdal.GDALGetRasterColorTable(hBand)
         if hTable == NULL:
             raise ValueError("NULL color table")
diff --git a/rasterio/_drivers.pyx b/rasterio/_drivers.pyx
index 26f6689..7d470e2 100644
--- a/rasterio/_drivers.pyx
+++ b/rasterio/_drivers.pyx
@@ -1,18 +1,24 @@
 # The GDAL and OGR driver registry.
 # GDAL driver management.
 
+import os
+import os.path
 import logging
+import sys
 
 from rasterio.five import string_types
 
+
 cdef extern from "cpl_conv.h":
     void    CPLFree (void *ptr)
     void    CPLSetThreadLocalConfigOption (char *key, char *val)
     const char * CPLGetConfigOption ( const char *key, const char *default)
 
+
 cdef extern from "cpl_error.h":
     void CPLSetErrorHandler (void *handler)
 
+
 cdef extern from "gdal.h":
     void GDALAllRegister()
     void GDALDestroyDriverManager()
@@ -21,17 +27,20 @@ cdef extern from "gdal.h":
     const char * GDALGetDriverShortName(void *driver)
     const char * GDALGetDriverLongName(void *driver)
 
+
 cdef extern from "ogr_api.h":
     void OGRRegisterAll()
     void OGRCleanupAll()
     int OGRGetDriverCount()
 
+
 log = logging.getLogger('GDAL')
 class NullHandler(logging.Handler):
     def emit(self, record):
         pass
 log.addHandler(NullHandler())
 
+
 level_map = {
     0: 0,
     1: logging.DEBUG,
@@ -84,6 +93,12 @@ cdef class GDALEnv(object):
         CPLSetErrorHandler(<void *>errorHandler)
         if driver_count() == 0:
             raise ValueError("Drivers not registered")
+
+        if 'GDAL_DATA' not in os.environ:
+            datadir = os.path.join(sys.prefix, 'share/gdal')
+            if os.path.exists(os.path.join(datadir, 'pcs.csv')):
+                os.environ['GDAL_DATA'] = datadir
+
         for key, val in self.options.items():
             key_b = key.upper().encode('utf-8')
             key_c = key_b
diff --git a/rasterio/_features.pyx b/rasterio/_features.pyx
index 2fc5ec6..3858af4 100644
--- a/rasterio/_features.pyx
+++ b/rasterio/_features.pyx
@@ -232,12 +232,14 @@ def _rasterize(shapes, image, transform, all_touched):
     image : numpy ndarray
         Array in which to store results.
     transform : Affine transformation object, optional
-        Transformation applied to shape geometries into pixel coordinates.
+        Transformation from pixel coordinates of `image` to the
+        coordinate system of the input `shapes`. See the `transform`
+        property of dataset objects.
     all_touched : boolean, optional
         If True, all pixels touched by geometries will be burned in.
-        If false, only pixels whose center is within the polygon or that are
-        selected by brezenhams line algorithm will be burned in.
-
+        If false, only pixels whose center is within the polygon or
+        that are selected by brezenhams line algorithm will be burned
+        in.
     """
 
     cdef int retval
diff --git a/rasterio/_io.pyx b/rasterio/_io.pyx
index 9ae404d..38edae0 100644
--- a/rasterio/_io.pyx
+++ b/rasterio/_io.pyx
@@ -22,6 +22,7 @@ from rasterio.five import text_type, string_types
 from rasterio.transform import Affine
 from rasterio.enums import ColorInterp
 
+
 log = logging.getLogger('rasterio')
 if 'all' in sys.warnoptions:
     # show messages in console with: python -W all
@@ -594,6 +595,16 @@ cdef class RasterReader(_base.DatasetReader):
             dtype = self.dtypes[0]
         else:  # unique dtype; normal case
             dtype = check_dtypes.pop()
+
+        # Windows are always limited to the dataset's extent.
+        if window:
+            window = eval_window(window, self.height, self.width)
+            window = ((
+                    min(window[0][0] or 0, self.height),
+                    min(window[0][1] or self.height, self.height)), (
+                    min(window[1][0] or 0, self.width),
+                    min(window[1][1] or self.width, self.width)))
+
         out_shape = (len(indexes),) + (
             window
             and window_shape(window, self.height, self.width)
diff --git a/rasterio/_warp.pyx b/rasterio/_warp.pyx
index 3137bf2..d9faaed 100644
--- a/rasterio/_warp.pyx
+++ b/rasterio/_warp.pyx
@@ -111,15 +111,16 @@ cdef void *_osr_from_crs(object crs):
     return osr
 
 
-def _transform(src_crs, dst_crs, xs, ys):
-    cdef double *x, *y
+def _transform(src_crs, dst_crs, xs, ys, zs):
+    cdef double *x, *y, *z = NULL
     cdef char *proj_c = NULL
     cdef void *src, *dst
     cdef void *transform
     cdef int i
 
     assert len(xs) == len(ys)
-    
+    assert zs is None or len(xs) == len(zs)
+
     src = _osr_from_crs(src_crs)
     dst = _osr_from_crs(dst_crs)
 
@@ -130,8 +131,13 @@ def _transform(src_crs, dst_crs, xs, ys):
         x[i] = xs[i]
         y[i] = ys[i]
 
+    if zs is not None:
+        z = <double *>_gdal.CPLMalloc(n*sizeof(double))
+        for i in range(n):
+            z[i] = zs[i]
+
     transform = _gdal.OCTNewCoordinateTransformation(src, dst)
-    res = _gdal.OCTTransform(transform, n, x, y, NULL)
+    res = _gdal.OCTTransform(transform, n, x, y, z)
     #if res:
     #    raise ValueError("Failed coordinate transformation")
 
@@ -142,12 +148,22 @@ def _transform(src_crs, dst_crs, xs, ys):
         res_xs[i] = x[i]
         res_ys[i] = y[i]
 
+    if zs is not None:
+        res_zs = [0]*n
+        for i in range(n):
+            res_zs[i] = z[i]
+        _gdal.CPLFree(z)
+
+        retval = (res_xs, res_ys, res_zs)
+    else:
+        retval = (res_xs, res_ys)
+
     _gdal.CPLFree(x)
     _gdal.CPLFree(y)
     _gdal.OCTDestroyCoordinateTransformation(transform)
     _gdal.OSRDestroySpatialReference(src)
     _gdal.OSRDestroySpatialReference(dst)
-    return res_xs, res_ys
+    return retval
 
 
 def _transform_geom(
diff --git a/rasterio/features.py b/rasterio/features.py
index 8e55cb8..ea5884a 100644
--- a/rasterio/features.py
+++ b/rasterio/features.py
@@ -182,26 +182,30 @@ def rasterize(
 
     Parameters
     ----------
-    shapes : iterable of (geometry, value) pairs or iterable over geometries
-        `geometry` can either be an object that implements the geo interface or
-        GeoJSON-like object.
+    shapes : iterable of (geometry, value) pairs or iterable over
+        geometries `geometry` can either be an object that implements
+        the geo interface or GeoJSON-like object.
     out_shape : tuple or list
-        Shape of output numpy ndarray
+        Shape of output numpy ndarray.
     fill : int or float, optional
-        Used as fill value for all areas not covered by input geometries
+        Used as fill value for all areas not covered by input
+        geometries.
     out : numpy ndarray, optional
-        Array of same shape and data type as `image` in which to store results.
+        Array of same shape and data type as `image` in which to store
+        results.
     output : older alias for `out`, will be removed before 1.0.
     transform : Affine transformation object, optional
-        transformation applied to shape geometries into pixel coordinates
+        Transformation from pixel coordinates of `image` to the
+        coordinate system of the input `shapes`. See the `transform`
+        property of dataset objects.
     all_touched : boolean, optional
-        If True, all pixels touched by geometries will be burned in.
-        If false, only pixels whose center is within the polygon or that are
-        selected by brezenhams line algorithm will be burned in.
+        If True, all pixels touched by geometries will be burned in.  If
+        false, only pixels whose center is within the polygon or that
+        are selected by brezenhams line algorithm will be burned in.
     default_value : int or float, optional
-        Used as value for all geometries, if not provided in `shapes`
+        Used as value for all geometries, if not provided in `shapes`.
     dtype : rasterio or numpy data type, optional
-        Used as data type for results, if `output` is not provided
+        Used as data type for results, if `output` is not provided.
 
     Returns
     -------
@@ -212,7 +216,8 @@ def rasterize(
     -----
     Valid data types for `fill`, `default_value`, `out`, `dtype` and
     shape values are rasterio.int16, rasterio.int32, rasterio.uint8,
-    rasterio.uint16, rasterio.uint32, rasterio.float32, rasterio.float64
+    rasterio.uint16, rasterio.uint32, rasterio.float32,
+    rasterio.float64.
 
     """
 
diff --git a/rasterio/transform.py b/rasterio/transform.py
index 4b3ed93..9b29945 100644
--- a/rasterio/transform.py
+++ b/rasterio/transform.py
@@ -1,12 +1,14 @@
-
 import warnings
 
 from affine import Affine
 
 IDENTITY = Affine.identity()
 
-def tastes_like_gdal(t):
-    return t[2] == t[4] == 0.0 and t[1] > 0 and t[5] < 0
+
+def tastes_like_gdal(seq):
+    """Return True if `seq` matches the GDAL geotransform pattern."""
+    return seq[2] == seq[4] == 0.0 and seq[1] > 0 and seq[5] < 0
+
 
 def guard_transform(transform):
     """Return an Affine transformation instance"""
@@ -20,10 +22,4 @@ def guard_transform(transform):
             transform = Affine.from_gdal(*transform)
         else:
             transform = Affine(*transform)
-    a, e = transform.a, transform.e
-    if a == 0.0 or e == 0.0:
-        raise ValueError(
-            "Transform has invalid coefficients a, e: (%f, %f)" % (
-                transform.a, transform.e))
     return transform
-
diff --git a/rasterio/warp.py b/rasterio/warp.py
index b01f841..25fd5a7 100644
--- a/rasterio/warp.py
+++ b/rasterio/warp.py
@@ -4,43 +4,139 @@ from rasterio._warp import _reproject, _transform, 
_transform_geom, RESAMPLING
 from rasterio.transform import guard_transform
 
 
-def transform(src_crs, dst_crs, xs, ys):
-    """Return transformed vectors of x and y."""
-    return _transform(src_crs, dst_crs, xs, ys)
+def transform(src_crs, dst_crs, xs, ys, zs=None):
+    """
+    Transform vectors of x, y and optionally z from source
+    coordinate reference system into target.
+
+    Parameters
+    ------------
+    src_crs: dict
+        Source coordinate reference system, in rasterio dict format.
+        Example: {'init': 'EPSG:4326'}
+    dst_crs: dict
+        Target coordinate reference system.
+    xs: array_like
+        Contains x values.  Will be cast to double floating point values.
+    ys:  array_like
+        Contains y values.
+    zs: array_like, optional
+        Contains z values.  Assumed to be all 0 if absent.
+
+    Returns
+    ---------
+    out: tuple of array_like, (xs, ys, [zs])
+    Tuple of x, y, and optionally z vectors, transformed into the target
+    coordinate reference system.
+    """
+    return _transform(src_crs, dst_crs, xs, ys, zs)
 
 
 def transform_geom(
-        src_crs, dst_crs, geom,
-        antimeridian_cutting=False, antimeridian_offset=10.0, precision=-1):
-    """Return transformed geometry."""
+        src_crs,
+        dst_crs,
+        geom,
+        antimeridian_cutting=False,
+        antimeridian_offset=10.0,
+        precision=-1):
+    """
+    Transform geometry from source coordinate reference system into target.
+
+    Parameters
+    ------------
+    src_crs: dict
+        Source coordinate reference system, in rasterio dict format.
+        Example: {'init': 'EPSG:4326'}
+    dst_crs: dict
+        Target coordinate reference system.
+    geom: GeoJSON like dict object
+    antimeridian_cutting: bool, optional
+        If True, cut geometries at the antimeridian, otherwise geometries will
+        not be cut (default).
+    antimeridian_offset: float
+        Offset from the antimeridian in degrees (default: 10) within which
+        any geometries will be split.
+    precision: float
+        If >= 0, geometry coordinates will be rounded to this number of decimal
+        places after the transform operation, otherwise original coordinate
+        values will be preserved (default).
+
+    Returns
+    ---------
+    out: GeoJSON like dict object
+        Transformed geometry in GeoJSON dict format
+    """
+
     return _transform_geom(
-        src_crs, dst_crs, geom,
-        antimeridian_cutting, antimeridian_offset, precision)
+        src_crs,
+        dst_crs,
+        geom,
+        antimeridian_cutting,
+        antimeridian_offset,
+        precision)
 
 
 def reproject(
-        source, destination,
-        src_transform=None, src_crs=None,
-        dst_transform=None, dst_crs=None,
+        source,
+        destination,
+        src_transform=None,
+        src_crs=None,
+        dst_transform=None,
+        dst_crs=None,
         resampling=RESAMPLING.nearest,
         **kwargs):
-    """Reproject a source raster to a destination.
+    """
+    Reproject a source raster to a destination raster.
 
-    If the source and destination are ndarrays, coordinate reference
-    system definitions and affine transformation parameters are required
-    for reprojection.
+    Parameters
+    ------------
+    source: ndarray or rasterio Band
+        Source raster.
+    destination: ndarray or rasterio Band
+        Target raster.
+    src_transform: affine transform object, optional
+        Source affine transformation.  Required if source and destination
+        are ndarrays.  Will be derived from source if it is a rasterio Band.
+    src_crs: dict, optional
+        Source coordinate reference system, in rasterio dict format.
+        Required if source and destination are ndarrays.
+        Will be derived from source if it is a rasterio Band.
+        Example: {'init': 'EPSG:4326'}
+    dst_transform: affine transform object, optional
+        Target affine transformation.  Required if source and destination
+        are ndarrays.  Will be derived from target if it is a rasterio Band.
+    dst_crs: dict, optional
+        Target coordinate reference system.  Required if source and destination
+        are ndarrays.  Will be derived from target if it is a rasterio Band.
+    resampling: int
+        Resampling method to use.  One of the following:
+            RESAMPLING.nearest,
+            RESAMPLING.bilinear,
+            RESAMPLING.cubic,
+            RESAMPLING.cubic_spline,
+            RESAMPLING.lanczos,
+            RESAMPLING.average,
+            RESAMPLING.mode
+    kwargs:  dict, optional
+        Additional arguments passed to transformation function.
 
-    If the source and destination are rasterio Bands, shorthand for
-    bands of datasets on disk, the coordinate reference systems and
-    transforms will be read from the appropriate datasets.
+    Returns
+    ---------
+    out: None
+        Output is written to destination.
     """
+
     if src_transform:
         src_transform = guard_transform(src_transform).to_gdal()
     if dst_transform:
         dst_transform = guard_transform(dst_transform).to_gdal()
 
     _reproject(
-        source, destination,
-        src_transform, src_crs,
-        dst_transform, dst_crs,
-        resampling, **kwargs)
+        source,
+        destination,
+        src_transform,
+        src_crs,
+        dst_transform,
+        dst_crs,
+        resampling,
+        **kwargs)
diff --git a/setup.py b/setup.py
index 98fbc4c..7e39bfa 100755
--- a/setup.py
+++ b/setup.py
@@ -124,9 +124,8 @@ with open('README.rst') as f:
 # Runtime requirements.
 inst_reqs = [
     'affine>=1.0',
-    'click',
-    'Numpy>=1.7',
-    'setuptools' ] 
+    'click>=3.0',
+    'Numpy>=1.7' ]
 
 if sys.version_info < (3, 4):
     inst_reqs.append('enum34')
diff --git a/tests/data/README.rst b/tests/data/README.rst
index 9c85140..0e63a6b 100644
--- a/tests/data/README.rst
+++ b/tests/data/README.rst
@@ -6,3 +6,9 @@ Rasterio's tests require several raster data files. Grab them 
from
 https://github.com/mapbox/rasterio/tree/master/tests/data
 
 and copy them to this directory.
+
+The RGB.byte.tif file is derived from USGS Landsat 7 ETM imagery. The shade.tif
+file is derived from USGS SRTM 90 data. The float.tif and float_nan.tif files
+are original works of the Rasterio authors. All test images are licensed under
+the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication:
+http://creativecommons.org/publicdomain/zero/1.0/.
diff --git a/tests/test_no_georef.py b/tests/test_no_georef.py
new file mode 100644
index 0000000..05807b6
--- /dev/null
+++ b/tests/test_no_georef.py
@@ -0,0 +1,30 @@
+# You should be able to write rasters with no georeferencing, e.g., plain old
+# PNGs and JPEGs.
+
+import rasterio
+
+
+def test_write(tmpdir):
+    name = str(tmpdir.join("test.png"))
+    with rasterio.open('tests/data/RGB.byte.tif') as src:
+        kwargs = src.meta.copy()
+        del kwargs['affine']
+        del kwargs['transform']
+        del kwargs['crs']
+        kwargs['driver'] = 'PNG'
+        with rasterio.open(name, 'w', **kwargs) as dst:
+            dst.write(src.read())
+
+
+def test_read_write(tmpdir):
+    tif1 = str(tmpdir.join("test.tif"))
+    tif2 = str(tmpdir.join("test2.tif"))
+    with rasterio.open('tests/data/RGB.byte.tif') as src:
+        kwargs = src.meta.copy()
+        del kwargs['affine']
+        del kwargs['transform']
+        del kwargs['crs']
+        with rasterio.open(tif1, 'w', **kwargs) as dst:
+            dst.write(src.read())
+    with rasterio.open(tif1) as src, rasterio.open(tif2, 'w', **src.meta) as 
dst:
+        dst.write(src.read())
diff --git a/tests/test_read.py b/tests/test_read.py
index f962138..61bd736 100644
--- a/tests/test_read.py
+++ b/tests/test_read.py
@@ -1,3 +1,5 @@
+import logging
+import sys
 import unittest
 
 import numpy
@@ -6,6 +8,9 @@ from hashlib import md5
 import rasterio
 
 
+logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
+
+
 class ReaderContextTest(unittest.TestCase):
 
     def test_context(self):
@@ -188,6 +193,27 @@ class ReaderContextTest(unittest.TestCase):
                                '6a675416a32fcb70fbcf601d01aeb6ee',
                                '94fd2733b534376c273a894f36ad4e0b'])
 
+    def test_read_window_overflow(self):
+        """Test graceful Numpy-like handling of windows that overflow
+        the dataset's bounds."""
+        with rasterio.open('tests/data/RGB.byte.tif') as s:
+            a = s.read(window=((None, 20000), (None, 20000)))
+            self.assertEqual(a.shape, (3,) + s.shape)
+
+    def test_read_window_beyond(self):
+        """Test graceful Numpy-like handling of windows beyond
+        the dataset's bounds."""
+        with rasterio.open('tests/data/RGB.byte.tif') as s:
+            a = s.read(window=((10000, 20000), (10000, 20000)))
+            self.assertEqual(a.shape, (3,0,0))
+
+    def test_read_window_overlap(self):
+        """Test graceful Numpy-like handling of windows beyond
+        the dataset's bounds."""
+        with rasterio.open('tests/data/RGB.byte.tif') as s:
+            a = s.read(window=((-100, 20000), (-100, 20000)))
+            self.assertEqual(a.shape, (3,100,100))
+
     def test_read_out(self):
         with rasterio.open('tests/data/RGB.byte.tif') as s:
             # regular array, without mask
diff --git a/tests/test_warp.py b/tests/test_warp.py
index d9fef2b..fcf33be 100644
--- a/tests/test_warp.py
+++ b/tests/test_warp.py
@@ -7,39 +7,56 @@ import affine
 import numpy
 
 import rasterio
-from rasterio.warp import reproject, RESAMPLING, transform_geom
+from rasterio.warp import reproject, RESAMPLING, transform_geom, transform
 
 
 logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)
 
+
+def test_transform():
+    """2D and 3D"""
+    WGS84_crs = {'init': 'EPSG:4326'}
+    WGS84_points = ([12.492269], [41.890169], [48.])
+    ECEF_crs = {'init': 'EPSG:4978'}
+    ECEF_points = ([4642610.], [1028584.], [4236562.])
+    ECEF_result = transform(WGS84_crs, ECEF_crs, *WGS84_points)
+    assert numpy.allclose(numpy.array(ECEF_result), numpy.array(ECEF_points))
+
+    UTM33_crs = {'init': 'EPSG:32633'}
+    UTM33_points = ([291952], [4640623])
+    UTM33_result = transform(WGS84_crs, UTM33_crs, *WGS84_points[:2])
+    assert numpy.allclose(numpy.array(UTM33_result), numpy.array(UTM33_points))
+
+
 def test_reproject():
     """Ndarry to ndarray"""
     with rasterio.drivers():
         with rasterio.open('tests/data/RGB.byte.tif') as src:
             source = src.read_band(1)
-        dst_transform = affine.Affine.from_gdal(-8789636.708, 300.0, 0.0, 
2943560.235, 0.0, -300.0)
+        dst_transform = affine.Affine.from_gdal(
+            -8789636.708, 300.0, 0.0, 2943560.235, 0.0, -300.0)
         dst_crs = dict(
-                    proj='merc',
-                    a=6378137,
-                    b=6378137,
-                    lat_ts=0.0,
-                    lon_0=0.0,
-                    x_0=0.0,
-                    y_0=0,
-                    k=1.0,
-                    units='m',
-                    nadgrids='@null',
-                    wktext=True,
-                    no_defs=True)
+            proj='merc',
+            a=6378137,
+            b=6378137,
+            lat_ts=0.0,
+            lon_0=0.0,
+            x_0=0.0,
+            y_0=0,
+            k=1.0,
+            units='m',
+            nadgrids='@null',
+            wktext=True,
+            no_defs=True)
         destin = numpy.empty(src.shape, dtype=numpy.uint8)
         reproject(
-            source, 
+            source,
             destin,
             src_transform=src.transform,
             src_crs=src.crs,
-            dst_transform=dst_transform, 
+            dst_transform=dst_transform,
             dst_crs=dst_crs,
-            resampling=RESAMPLING.nearest )
+            resampling=RESAMPLING.nearest)
     assert destin.any()
     try:
         import matplotlib.pyplot as plt
@@ -49,35 +66,36 @@ def test_reproject():
     except:
         pass
 
+
 def test_reproject_multi():
     """Ndarry to ndarray"""
     with rasterio.drivers():
         with rasterio.open('tests/data/RGB.byte.tif') as src:
             source = src.read()
         dst_transform = affine.Affine.from_gdal(
-                            -8789636.708, 300.0, 0.0, 2943560.235, 0.0, -300.0)
+            -8789636.708, 300.0, 0.0, 2943560.235, 0.0, -300.0)
         dst_crs = dict(
-                    proj='merc',
-                    a=6378137,
-                    b=6378137,
-                    lat_ts=0.0,
-                    lon_0=0.0,
-                    x_0=0.0,
-                    y_0=0,
-                    k=1.0,
-                    units='m',
-                    nadgrids='@null',
-                    wktext=True,
-                    no_defs=True)
+            proj='merc',
+            a=6378137,
+            b=6378137,
+            lat_ts=0.0,
+            lon_0=0.0,
+            x_0=0.0,
+            y_0=0,
+            k=1.0,
+            units='m',
+            nadgrids='@null',
+            wktext=True,
+            no_defs=True)
         destin = numpy.empty(source.shape, dtype=numpy.uint8)
         reproject(
-            source, 
+            source,
             destin,
             src_transform=src.transform,
             src_crs=src.crs,
-            dst_transform=dst_transform, 
+            dst_transform=dst_transform,
             dst_crs=dst_crs,
-            resampling=RESAMPLING.nearest )
+            resampling=RESAMPLING.nearest)
     assert destin.any()
     try:
         import matplotlib.pyplot as plt
@@ -87,28 +105,30 @@ def test_reproject_multi():
     except:
         pass
 
+
 def test_warp_from_file():
     """File to ndarray"""
     with rasterio.open('tests/data/RGB.byte.tif') as src:
-        dst_transform = affine.Affine.from_gdal(-8789636.708, 300.0, 0.0, 
2943560.235, 0.0, -300.0)
+        dst_transform = affine.Affine.from_gdal(
+            -8789636.708, 300.0, 0.0, 2943560.235, 0.0, -300.0)
         dst_crs = dict(
-                    proj='merc',
-                    a=6378137,
-                    b=6378137,
-                    lat_ts=0.0,
-                    lon_0=0.0,
-                    x_0=0.0,
-                    y_0=0,
-                    k=1.0,
-                    units='m',
-                    nadgrids='@null',
-                    wktext=True,
-                    no_defs=True)
+            proj='merc',
+            a=6378137,
+            b=6378137,
+            lat_ts=0.0,
+            lon_0=0.0,
+            x_0=0.0,
+            y_0=0,
+            k=1.0,
+            units='m',
+            nadgrids='@null',
+            wktext=True,
+            no_defs=True)
         destin = numpy.empty(src.shape, dtype=numpy.uint8)
         reproject(
-            rasterio.band(src, 1), 
-            destin, 
-            dst_transform=dst_transform, 
+            rasterio.band(src, 1),
+            destin,
+            dst_transform=dst_transform,
             dst_crs=dst_crs)
     assert destin.any()
     try:
@@ -119,24 +139,26 @@ def test_warp_from_file():
     except:
         pass
 
+
 def test_warp_from_to_file(tmpdir):
     """File to file"""
     tiffname = str(tmpdir.join('foo.tif'))
     with rasterio.open('tests/data/RGB.byte.tif') as src:
-        dst_transform = affine.Affine.from_gdal(-8789636.708, 300.0, 0.0, 
2943560.235, 0.0, -300.0)
+        dst_transform = affine.Affine.from_gdal(
+            -8789636.708, 300.0, 0.0, 2943560.235, 0.0, -300.0)
         dst_crs = dict(
-                    proj='merc',
-                    a=6378137,
-                    b=6378137,
-                    lat_ts=0.0,
-                    lon_0=0.0,
-                    x_0=0.0,
-                    y_0=0,
-                    k=1.0,
-                    units='m',
-                    nadgrids='@null',
-                    wktext=True,
-                    no_defs=True)
+            proj='merc',
+            a=6378137,
+            b=6378137,
+            lat_ts=0.0,
+            lon_0=0.0,
+            x_0=0.0,
+            y_0=0,
+            k=1.0,
+            units='m',
+            nadgrids='@null',
+            wktext=True,
+            no_defs=True)
         kwargs = src.meta.copy()
         kwargs.update(
             transform=dst_transform,
@@ -146,24 +168,26 @@ def test_warp_from_to_file(tmpdir):
                 reproject(rasterio.band(src, i), rasterio.band(dst, i))
     # subprocess.call(['open', tiffname])
 
+
 def test_warp_from_to_file_multi(tmpdir):
     """File to file"""
     tiffname = str(tmpdir.join('foo.tif'))
     with rasterio.open('tests/data/RGB.byte.tif') as src:
-        dst_transform = affine.Affine.from_gdal(-8789636.708, 300.0, 0.0, 
2943560.235, 0.0, -300.0)
+        dst_transform = affine.Affine.from_gdal(
+            -8789636.708, 300.0, 0.0, 2943560.235, 0.0, -300.0)
         dst_crs = dict(
-                    proj='merc',
-                    a=6378137,
-                    b=6378137,
-                    lat_ts=0.0,
-                    lon_0=0.0,
-                    x_0=0.0,
-                    y_0=0,
-                    k=1.0,
-                    units='m',
-                    nadgrids='@null',
-                    wktext=True,
-                    no_defs=True)
+            proj='merc',
+            a=6378137,
+            b=6378137,
+            lat_ts=0.0,
+            lon_0=0.0,
+            x_0=0.0,
+            y_0=0,
+            k=1.0,
+            units='m',
+            nadgrids='@null',
+            wktext=True,
+            no_defs=True)
         kwargs = src.meta.copy()
         kwargs.update(
             transform=dst_transform,
@@ -171,14 +195,67 @@ def test_warp_from_to_file_multi(tmpdir):
         with rasterio.open(tiffname, 'w', **kwargs) as dst:
             for i in (1, 2, 3):
                 reproject(
-                    rasterio.band(src, i), 
+                    rasterio.band(src, i),
                     rasterio.band(dst, i),
                     num_threads=2)
     # subprocess.call(['open', tiffname])
 
-def test_transform_geom_wrap():
-    geom = {'type': 'Polygon', 'coordinates': (((798842.3090855901, 
6569056.500655151), (756688.2826828464, 6412397.888771972), (755571.0617232556, 
6408461.009397383), (677605.2284582685, 6425600.39266733), (677605.2284582683, 
6425600.392667332), (670873.3791649605, 6427248.603432341), (664882.1106069803, 
6407585.48425362), (663675.8662823177, 6403676.990080649), (485120.71963574126, 
6449787.167760638), (485065.55660851026, 6449802.826920689), 
(485957.03982722526, 6452708.625101285), (48 [...]
+
+def test_transform_geom():
+    geom = {
+        'type': 'Polygon',
+        'coordinates': (
+            ((798842.3090855901, 6569056.500655151),
+                (756688.2826828464, 6412397.888771972),
+                (755571.0617232556, 6408461.009397383),
+                (677605.2284582685, 6425600.39266733),
+                (677605.2284582683, 6425600.392667332),
+                (670873.3791649605, 6427248.603432341),
+                (664882.1106069803, 6407585.48425362),
+                (663675.8662823177, 6403676.990080649),
+                (485120.71963574126, 6449787.167760638),
+                (485065.55660851026, 6449802.826920689),
+                (485957.03982722526, 6452708.625101285),
+                (487541.24541826674, 6457883.292107048),
+                (531008.5797472061, 6605816.560367976),
+                (530943.7197027118, 6605834.9333479265),
+                (531888.5010308184, 6608940.750411527),
+                (533299.5981959199, 6613962.642851984),
+                (533403.6388841148, 6613933.172096095),
+                (576345.6064638699, 6761983.708069147),
+                (577649.6721159086, 6766698.137844516),
+                (578600.3589008929, 6770143.99782289),
+                (578679.4732294685, 6770121.638265098),
+                (655836.640492081, 6749376.357102599),
+                (659913.0791150068, 6764770.1314677475),
+                (661105.8478791204, 6769515.168134831),
+                (661929.4670843681, 6772800.8565198565),
+                (661929.4670843673, 6772800.856519875),
+                (661975.1582566603, 6772983.354777632),
+                (662054.7979028501, 6772962.86384242),
+                (841909.6014891531, 6731793.200435557),
+                (840726.455490463, 6727039.8672589315),
+                (798842.3090855901, 6569056.500655151)),
+            )
+    }
+
+    result = transform_geom('EPSG:3373', 'EPSG:4326', geom)
+    assert result['type'] == 'Polygon'
+    assert len(result['coordinates']) == 1
+
     result = transform_geom(
-                'EPSG:3373', 'EPSG:4326', geom, antimeridian_cutting=True)
+        'EPSG:3373', 'EPSG:4326', geom, antimeridian_cutting=True)
     assert result['type'] == 'MultiPolygon'
     assert len(result['coordinates']) == 2
+
+    result = transform_geom(
+        'EPSG:3373', 
+        'EPSG:4326', 
+        geom, 
+        antimeridian_cutting=True, 
+        antimeridian_offset=0)
+    assert result['type'] == 'MultiPolygon'
+    assert len(result['coordinates']) == 2
+
+    result = transform_geom('EPSG:3373', 'EPSG:4326',  geom,  precision=1)
+    assert int(result['coordinates'][0][0][0] * 10) == -1778

-- 
Alioth's /usr/local/bin/git-commit-notice on 
/srv/git.debian.org/git/pkg-grass/rasterio.git

_______________________________________________
Pkg-grass-devel mailing list
Pkg-grass-devel@lists.alioth.debian.org
http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-grass-devel

Reply via email to