shapely 1.5.4__tar.gz → 1.5.5__tar.gz

{Shapely-1.5.4 → Shapely-1.5.5}/CHANGES.txt

@@ -1,6 +1,10 @@
 Changes
 =======
 
+1.5.5 (2015-01-20)
+------------------
+- MANIFEST changes to restore _geox.pxi (#231).
+
 1.5.4 (2015-01-19)
 ------------------
 - Fixed OS X binary wheel library load path (#224).

{Shapely-1.5.4/Shapely.egg-info → Shapely-1.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Shapely
-Version: 1.5.4
+Version: 1.5.5
 Summary: Geometric objects, predicates, and operations
 Home-page: https://github.com/Toblerity/Shapely
 Author: Sean Gillies
@@ -215,6 +215,10 @@ Description: =======
         Changes
         =======
         
+        1.5.5 (2015-01-20)
+        ------------------
+        - MANIFEST changes to restore _geox.pxi (#231).
+        
         1.5.4 (2015-01-19)
         ------------------
         - Fixed OS X binary wheel library load path (#224).

{Shapely-1.5.4 → Shapely-1.5.5/Shapely.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: Shapely
-Version: 1.5.4
+Version: 1.5.5
 Summary: Geometric objects, predicates, and operations
 Home-page: https://github.com/Toblerity/Shapely
 Author: Sean Gillies
@@ -215,6 +215,10 @@ Description: =======
         Changes
         =======
         
+        1.5.5 (2015-01-20)
+        ------------------
+        - MANIFEST changes to restore _geox.pxi (#231).
+        
         1.5.4 (2015-01-19)
         ------------------
         - Fixed OS X binary wheel library load path (#224).

{Shapely-1.5.4 → Shapely-1.5.5}/Shapely.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ docs/index.rst
 docs/manual.rst
 docs/project.rst
 shapely/__init__.py
+shapely/_geos.pxi
 shapely/affinity.py
 shapely/coords.py
 shapely/ctypes_declarations.py
@@ -48,6 +49,7 @@ shapely/geometry/polygon.py
 shapely/geometry/proxy.py
 shapely/speedups/__init__.py
 shapely/speedups/_speedups.c
+shapely/speedups/_speedups.pyx
 shapely/vectorized/__init__.py
 shapely/vectorized/_vectorized.pyx
 tests/__init__.py

Shapely-1.5.5/VERSION.txt

@@ -0,0 +1 @@
+1.5.5

{Shapely-1.5.4 → Shapely-1.5.5}/setup.py

@@ -257,12 +257,13 @@ ext_modules = [
         include_dirs=[get_config_var('INCLUDEDIR')],),
 ]
 
+cmd_classes = setup_args.setdefault('cmdclass', {})
+
 try:
     import numpy as np
     from Cython.Distutils import build_ext as cython_build_ext
     from distutils.extension import Extension as DistutilsExtension
 
-    cmd_classes = setup_args.setdefault('cmdclass', {})
     if 'build_ext' in cmd_classes:
         raise ValueError('We need to put the Cython build_ext in '
                          'cmd_classes, but it is already defined.')
@@ -295,6 +296,9 @@ except BuildFailed as ex:
     print("Failure information, if any, is above.")
     print("I'm retrying the build without the C extension now.")
 
+    if 'build_ext' in cmd_classes:
+        del cmd_classes['build_ext']
+
     setup(**setup_args)
 
     print(BUILD_EXT_WARNING)

Shapely-1.5.5/shapely/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.5.5"

Shapely-1.5.5/shapely/_geos.pxi

@@ -0,0 +1,58 @@
+# The beginnings of a Cython definition of GEOS. In the future much of this
+# could be auto-generated.
+
+ctypedef long ptr
+
+
+cdef extern from "geos_c.h":
+    ctypedef void *GEOSContextHandle_t
+    ctypedef struct GEOSGeometry
+    ctypedef struct GEOSCoordSequence
+    ctypedef struct GEOSPreparedGeometry
+    
+    GEOSCoordSequence *GEOSCoordSeq_create_r(GEOSContextHandle_t, unsigned int, unsigned int) nogil
+    GEOSCoordSequence *GEOSGeom_getCoordSeq_r(GEOSContextHandle_t, GEOSGeometry *) nogil
+
+    int GEOSCoordSeq_getSize_r(GEOSContextHandle_t, GEOSCoordSequence *, int *) nogil
+    int GEOSCoordSeq_setX_r(GEOSContextHandle_t, GEOSCoordSequence *, int, double) nogil
+    int GEOSCoordSeq_setY_r(GEOSContextHandle_t, GEOSCoordSequence *, int, double) nogil
+    int GEOSCoordSeq_setZ_r(GEOSContextHandle_t, GEOSCoordSequence *, int, double) nogil
+    int GEOSCoordSeq_getX_r(GEOSContextHandle_t, GEOSCoordSequence *, int, double *) nogil
+    int GEOSCoordSeq_getY_r(GEOSContextHandle_t, GEOSCoordSequence *, int, double *) nogil
+    int GEOSCoordSeq_getZ_r(GEOSContextHandle_t, GEOSCoordSequence *, int, double *) nogil
+
+    GEOSGeometry *GEOSGeom_createPoint_r(GEOSContextHandle_t, GEOSCoordSequence *) nogil
+    GEOSGeometry *GEOSGeom_createLineString_r(GEOSContextHandle_t, GEOSCoordSequence *) nogil
+    GEOSGeometry *GEOSGeom_createLinearRing_r(GEOSContextHandle_t, GEOSCoordSequence *) nogil
+    GEOSGeometry *GEOSGeom_clone_r(GEOSContextHandle_t, GEOSGeometry *) nogil
+    GEOSCoordSequence *GEOSCoordSeq_clone_r(GEOSContextHandle_t, GEOSCoordSequence *) nogil
+
+    void GEOSGeom_destroy_r(GEOSContextHandle_t, GEOSGeometry *) nogil
+
+    char GEOSPreparedContains_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedContainsProperly_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedCoveredBy_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedCovers_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedCrosses_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedDisjoint_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedIntersects_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedOverlaps_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedTouches_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+    char GEOSPreparedWithin_r(GEOSContextHandle_t, const GEOSPreparedGeometry*, const GEOSGeometry*) nogil
+
+    char GEOSHasZ_r(GEOSContextHandle_t, GEOSGeometry *) nogil
+    char GEOSisRing_r(GEOSContextHandle_t, GEOSGeometry *) nogil
+    char GEOSisClosed_r(GEOSContextHandle_t, GEOSGeometry *) nogil
+
+
+cdef GEOSContextHandle_t get_geos_context_handle():
+    # Note: This requires that lgeos is defined, so needs to be imported as:
+    from shapely.geos import lgeos
+    cdef ptr handle = lgeos.geos_handle
+    return <GEOSContextHandle_t>handle
+
+
+cdef GEOSPreparedGeometry *geos_from_prepared(shapely_geom) except *:
+    """Get the Prepared GEOS geometry pointer from the given shapely geometry."""
+    cdef ptr geos_geom = shapely_geom._geom
+    return <GEOSPreparedGeometry *>geos_geom

Shapely-1.5.5/shapely/speedups/_speedups.pyx

@@ -0,0 +1,498 @@
+# geos_linestring_from_py was transcribed from shapely.geometry.linestring
+# geos_linearring_from_py was transcribed from shapely.geometry.polygon
+# coordseq_ctypes was transcribed from shapely.coords.CoordinateSequence.ctypes
+#
+# Copyright (c) 2007, Sean C. Gillies
+# Transcription to cython: Copyright (c) 2011, Oliver Tonnhofer
+
+import ctypes
+
+from shapely.coords import required
+from shapely.geos import lgeos
+from shapely.geometry import Point, LineString, LinearRing
+from shapely.geometry.base import geom_factory
+
+include "../_geos.pxi"
+    
+
+cdef inline GEOSGeometry *cast_geom(unsigned long geom_addr):
+    return <GEOSGeometry *>geom_addr
+
+
+cdef inline GEOSContextHandle_t cast_handle(unsigned long handle_addr):
+    return <GEOSContextHandle_t>handle_addr
+
+
+cdef inline GEOSCoordSequence *cast_seq(unsigned long handle_addr):
+    return <GEOSCoordSequence *>handle_addr
+
+
+def destroy(geom):
+    GEOSGeom_destroy_r(cast_handle(lgeos.geos_handle), cast_geom(geom))
+
+
+def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
+    cdef double *cp
+    cdef GEOSContextHandle_t handle = cast_handle(lgeos.geos_handle)
+    cdef GEOSCoordSequence *cs
+    cdef GEOSGeometry *g
+    cdef double dx, dy, dz
+    cdef int i, n, m, sm, sn
+
+    # If a LineString is passed in, just clone it and return
+    # If a LinearRing is passed in, clone the coord seq and return a LineString
+    if isinstance(ob, LineString):
+        g = cast_geom(ob._geom)
+        if GEOSHasZ_r(handle, g):
+            n = 3
+        else:
+            n = 2
+
+        if type(ob) == LineString:
+            return <unsigned long>GEOSGeom_clone_r(handle, g), n
+        else:
+            cs = GEOSGeom_getCoordSeq_r(handle, g)
+            cs = GEOSCoordSeq_clone_r(handle, cs)
+            return <unsigned long>GEOSGeom_createLineString_r(handle, cs), n
+
+    # If numpy is present, we use numpy.require to ensure that we have a
+    # C-continguous array that owns its data. View data will be copied.
+    ob = required(ob)
+    try:
+        # From array protocol
+        array = ob.__array_interface__
+        assert len(array['shape']) == 2
+        m = array['shape'][0]
+        if m < 2:
+            raise ValueError(
+                "LineStrings must have at least 2 coordinate tuples")
+        try:
+            n = array['shape'][1]
+        except IndexError:
+            raise ValueError(
+                "Input %s is the wrong shape for a LineString" % str(ob))
+        assert n == 2 or n == 3
+
+        # Make pointer to the coordinate array
+        if isinstance(array['data'], ctypes.Array):
+            cp = <double *><unsigned long>ctypes.addressof(array['data'])
+        else:
+            cp = <double *><unsigned long>array['data'][0]
+
+        # Use strides to properly index into cp
+        # ob[i, j] == cp[sm*i + sn*j]
+        # Just to avoid a referenced before assignment warning.
+        dx = 0
+        if array.get('strides', None):
+            sm = array['strides'][0]/sizeof(dx)
+            sn = array['strides'][1]/sizeof(dx)
+        else:
+            sm = n
+            sn = 1
+
+        # Create a coordinate sequence
+        if update_geom is not None:
+            cs = GEOSGeom_getCoordSeq_r(handle, cast_geom(update_geom))
+            if n != update_ndim:
+                raise ValueError(
+                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
+                % update_ndim)
+        else:
+            cs = GEOSCoordSeq_create_r(handle, <int>m, <int>n)
+
+        # add to coordinate sequence
+        for i in xrange(m):
+            dx = cp[sm*i]
+            dy = cp[sm*i+sn]
+            dz = 0
+            if n == 3:
+                dz = cp[sm*i+2*sn]
+                
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            GEOSCoordSeq_setX_r(handle, cs, i, dx)
+            GEOSCoordSeq_setY_r(handle, cs, i, dy)
+            if n == 3:
+                GEOSCoordSeq_setZ_r(handle, cs, i, dz)
+
+    except AttributeError:
+        # Fall back on list
+        try:
+            m = len(ob)
+        except TypeError:  # Iterators, e.g. Python 3 zip
+            ob = list(ob)
+            m = len(ob)
+        if m < 2:
+            raise ValueError(
+                "LineStrings must have at least 2 coordinate tuples")
+
+        def _coords(o):
+            if isinstance(o, Point):
+                return o.coords[0]
+            else:
+                return o
+
+        try:
+            n = len(_coords(ob[0]))
+        except TypeError:
+            raise ValueError(
+                "Input %s is the wrong shape for a LineString" % str(ob))
+        assert n == 2 or n == 3
+
+        # Create a coordinate sequence
+        if update_geom is not None:
+            cs = GEOSGeom_getCoordSeq_r(handle, cast_geom(update_geom))
+            if n != update_ndim:
+                raise ValueError(
+                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
+                % update_ndim)
+        else:
+            cs = GEOSCoordSeq_create_r(handle, <int>m, <int>n)
+
+        # add to coordinate sequence
+        for i in xrange(m):
+            coords = _coords(ob[i])
+            dx = coords[0]
+            dy = coords[1]
+            dz = 0
+            if n == 3:
+                if len(coords) != 3:
+                    raise ValueError("Inconsistent coordinate dimensionality")
+                dz = coords[2]
+            
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            GEOSCoordSeq_setX_r(handle, cs, i, dx)
+            GEOSCoordSeq_setY_r(handle, cs, i, dy)
+            if n == 3:
+                GEOSCoordSeq_setZ_r(handle, cs, i, dz)
+
+    if update_geom is not None:
+        return None
+    else:
+        return <unsigned long>GEOSGeom_createLineString_r(handle, cs), n
+
+
+def geos_linearring_from_py(ob, update_geom=None, update_ndim=0):
+    cdef double *cp
+    cdef GEOSContextHandle_t handle = cast_handle(lgeos.geos_handle)
+    cdef GEOSGeometry *g
+    cdef GEOSCoordSequence *cs
+    cdef double dx, dy, dz
+    cdef int i, n, m, M, sm, sn
+
+    # If a LinearRing is passed in, just clone it and return
+    # If a LineString is passed in, clone the coord seq and return a LinearRing
+    if isinstance(ob, LineString):
+        g = cast_geom(ob._geom)
+        if GEOSHasZ_r(handle, g):
+            n = 3
+        else:
+            n = 2
+
+        if type(ob) == LinearRing:
+            return <unsigned long>GEOSGeom_clone_r(handle, g), n
+        else:
+            cs = GEOSGeom_getCoordSeq_r(handle, g)
+            GEOSCoordSeq_getSize_r(handle, cs, &m)
+            if GEOSisClosed_r(handle, g) and m >= 4:
+                cs = GEOSCoordSeq_clone_r(handle, cs)
+                return <unsigned long>GEOSGeom_createLinearRing_r(handle, cs), n
+
+    # If numpy is present, we use numpy.require to ensure that we have a
+    # C-continguous array that owns its data. View data will be copied.
+    ob = required(ob)
+    try:
+        # From array protocol
+        array = ob.__array_interface__
+        assert len(array['shape']) == 2
+        m = array['shape'][0]
+        n = array['shape'][1]
+        if m < 3:
+            raise ValueError(
+                "A LinearRing must have at least 3 coordinate tuples")
+        assert n == 2 or n == 3
+
+        # Make pointer to the coordinate array
+        if isinstance(array['data'], ctypes.Array):
+            cp = <double *><unsigned long>ctypes.addressof(array['data'])
+        else:
+            cp = <double *><unsigned long>array['data'][0]
+
+        # Use strides to properly index into cp
+        # ob[i, j] == cp[sm*i + sn*j]
+        dx = 0  # Just to avoid a referenced before assignment warning.
+        if array.get('strides', None):
+            sm = array['strides'][0]/sizeof(dx)
+            sn = array['strides'][1]/sizeof(dx)
+        else:
+            sm = n
+            sn = 1
+
+        # Add closing coordinates to sequence?
+        # Check whether the first set of coordinates matches the last.
+        # If not, we'll have to close the ring later
+        if (cp[0] != cp[sm*(m-1)] or cp[sn] != cp[sm*(m-1)+sn] or
+            (n == 3 and cp[2*sn] != cp[sm*(m-1)+2*sn])):
+            M = m + 1
+        else:
+            M = m
+
+        # Create a coordinate sequence
+        if update_geom is not None:
+            cs = GEOSGeom_getCoordSeq_r(handle, cast_geom(update_geom))
+            if n != update_ndim:
+                raise ValueError(
+                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
+                % update_ndim)
+        else:
+            cs = GEOSCoordSeq_create_r(handle, M, n)
+
+        # add to coordinate sequence
+        for i in xrange(m):
+            dx = cp[sm*i]
+            dy = cp[sm*i+sn]
+            dz = 0
+            if n == 3:
+                dz = cp[sm*i+2*sn]
+        
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            GEOSCoordSeq_setX_r(handle, cs, i, dx)
+            GEOSCoordSeq_setY_r(handle, cs, i, dy)
+            if n == 3:
+                GEOSCoordSeq_setZ_r(handle, cs, i, dz)
+
+        # Add closing coordinates to sequence?
+        if M > m:
+            dx = cp[0]
+            dy = cp[sn]
+            dz = 0
+            if n == 3:
+                dz = cp[2*sn]
+        
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            GEOSCoordSeq_setX_r(handle, cs, M-1, dx)
+            GEOSCoordSeq_setY_r(handle, cs, M-1, dy)
+            if n == 3:
+                GEOSCoordSeq_setZ_r(handle, cs, M-1, dz)
+            
+    except AttributeError:
+        # Fall back on list
+        try:
+            m = len(ob)
+        except TypeError:  # Iterators, e.g. Python 3 zip
+            ob = list(ob)
+            m = len(ob)
+        n = len(ob[0])
+        if m < 3:
+            raise ValueError(
+                "A LinearRing must have at least 3 coordinate tuples")
+        assert (n == 2 or n == 3)
+
+        # Add closing coordinates if not provided
+        if m == 3 or ob[0][0] != ob[-1][0] or ob[0][1] != ob[-1][1]:
+            M = m + 1
+        else:
+            M = m
+
+        # Create a coordinate sequence
+        if update_geom is not None:
+            cs = GEOSGeom_getCoordSeq_r(handle, cast_geom(update_geom))
+            if n != update_ndim:
+                raise ValueError(
+                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
+                % update_ndim)
+        else:
+            cs = GEOSCoordSeq_create_r(handle, M, n)
+        
+        # add to coordinate sequence
+        for i in xrange(m):
+            coords = ob[i]
+            dx = coords[0]
+            dy = coords[1]
+            dz = 0
+            if n == 3:
+                dz = coords[2]
+        
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            GEOSCoordSeq_setX_r(handle, cs, i, dx)
+            GEOSCoordSeq_setY_r(handle, cs, i, dy)
+            if n == 3:
+                GEOSCoordSeq_setZ_r(handle, cs, i, dz)
+
+        # Add closing coordinates to sequence?
+        if M > m:
+            coords = ob[0]
+            dx = coords[0]
+            dy = coords[1]
+            dz = 0
+            if n == 3:
+                dz = coords[2]
+        
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            GEOSCoordSeq_setX_r(handle, cs, M-1, dx)
+            GEOSCoordSeq_setY_r(handle, cs, M-1, dy)
+            if n == 3:
+                GEOSCoordSeq_setZ_r(handle, cs, M-1, dz)
+
+    if update_geom is not None:
+        return None
+    else:
+        return <unsigned long>GEOSGeom_createLinearRing_r(handle, cs), n
+
+
+def coordseq_ctypes(self):
+    cdef int i, n, m
+    cdef double temp = 0
+    cdef GEOSContextHandle_t handle = cast_handle(lgeos.geos_handle)
+    cdef GEOSCoordSequence *cs
+    cdef double *data_p
+    self._update()
+    n = self._ndim
+    m = self.__len__()
+    array_type = ctypes.c_double * (m * n)
+    data = array_type()
+    
+    cs = cast_seq(self._cseq)
+    data_p = <double *><unsigned long>ctypes.addressof(data)
+    
+    for i in xrange(m):
+        GEOSCoordSeq_getX_r(handle, cs, i, &temp)
+        data_p[n*i] = temp
+        GEOSCoordSeq_getY_r(handle, cs, i, &temp)
+        data_p[n*i+1] = temp
+        if n == 3: # TODO: use hasz
+            GEOSCoordSeq_getZ_r(handle, cs, i, &temp)
+            data_p[n*i+2] = temp
+    return data
+
+def coordseq_iter(self):
+    cdef int i
+    cdef double dx
+    cdef double dy
+    cdef double dz
+    cdef int has_z
+
+    self._update()
+
+    cdef GEOSContextHandle_t handle = cast_handle(lgeos.geos_handle)
+    cdef GEOSCoordSequence *cs
+    cs = cast_seq(self._cseq)
+
+    has_z = self._ndim == 3
+    for i in range(self.__len__()):
+        GEOSCoordSeq_getX_r(handle, cs, i, &dx)
+        GEOSCoordSeq_getY_r(handle, cs, i, &dy)
+        if has_z == 1:
+            GEOSCoordSeq_getZ_r(handle, cs, i, &dz)
+            yield (dx, dy, dz)
+        else:
+            yield (dx, dy)
+
+cdef GEOSCoordSequence* transform(GEOSCoordSequence* cs,
+                                  int ndim,
+                                  double a,
+                                  double b,
+                                  double c,
+                                  double d,
+                                  double e,
+                                  double f,
+                                  double g,
+                                  double h,
+                                  double i,
+                                  double xoff,
+                                  double yoff,
+                                  double zoff):
+    """Performs an affine transformation on a GEOSCoordSequence
+    
+    Returns the transformed coordinate sequence
+    """
+    cdef GEOSContextHandle_t handle = cast_handle(lgeos.geos_handle)
+    cdef int m
+    cdef GEOSCoordSequence *cs_t
+    cdef double x, y, z
+    cdef double x_t, y_t, z_t
+    
+    # create a new coordinate sequence with the same size and dimensions
+    GEOSCoordSeq_getSize_r(handle, cs, &m)
+    cs_t = GEOSCoordSeq_create_r(handle, m, ndim)
+    
+    # perform the transform
+    for n in range(0, m):
+        GEOSCoordSeq_getX_r(handle, cs, n, &x)
+        GEOSCoordSeq_getY_r(handle, cs, n, &y)
+        x_t = a * x + b * y + xoff
+        y_t = d * x + e * y + yoff
+        GEOSCoordSeq_setX_r(handle, cs_t, n, x_t)
+        GEOSCoordSeq_setY_r(handle, cs_t, n, y_t)
+    if ndim == 3:
+        for n in range(0, m):
+            GEOSCoordSeq_getZ_r(handle, cs, n, &z)
+            z_t = g * x + h * y + i * z + zoff
+            GEOSCoordSeq_setZ_r(handle, cs_t, n, z_t)
+    
+    return cs_t
+
+cpdef affine_transform(geom, matrix):
+    cdef double a, b, c, d, e, f, g, h, i, xoff, yoff, zoff
+    if geom.is_empty:
+        return geom
+    if len(matrix) == 6:
+        ndim = 2
+        a, b, d, e, xoff, yoff = matrix
+        if geom.has_z:
+            ndim = 3
+            i = 1.0
+            c = f = g = h = zoff = 0.0
+            matrix = a, b, c, d, e, f, g, h, i, xoff, yoff, zoff
+    elif len(matrix) == 12:
+        ndim = 3
+        a, b, c, d, e, f, g, h, i, xoff, yoff, zoff = matrix
+        if not geom.has_z:
+            ndim = 2
+            matrix = a, b, d, e, xoff, yoff
+    else:
+        raise ValueError("'matrix' expects either 6 or 12 coefficients")
+    
+    cdef GEOSContextHandle_t handle = cast_handle(lgeos.geos_handle)
+    cdef GEOSCoordSequence *cs
+    cdef GEOSCoordSequence *cs_t
+    cdef GEOSGeometry *the_geom
+    cdef GEOSGeometry *the_geom_t
+    cdef int m, n
+    cdef double x, y, z
+    cdef double x_t, y_t, z_t
+    
+    # Process coordinates from each supported geometry type
+    if geom.type in ('Point', 'LineString', 'LinearRing'):
+        the_geom = cast_geom(geom._geom)
+        cs = GEOSGeom_getCoordSeq_r(handle, the_geom)
+        
+        # perform the transformation
+        cs_t = transform(cs, ndim, a, b, c, d, e, f, g, h, i, xoff, yoff, zoff)
+        
+        # create a new geometry from the coordinate sequence
+        if geom.type == 'Point':
+            the_geom_t = GEOSGeom_createPoint_r(handle, cs_t)
+        elif geom.type == 'LineString':
+            the_geom_t = GEOSGeom_createLineString_r(handle, cs_t)
+        elif geom.type == 'LinearRing':
+            the_geom_t = GEOSGeom_createLinearRing_r(handle, cs_t)
+        
+        # return the geometry as a Python object
+        return geom_factory(<unsigned long>the_geom_t)
+    elif geom.type == 'Polygon':
+        ring = geom.exterior
+        shell = affine_transform(ring, matrix)
+        holes = list(geom.interiors)
+        for pos, ring in enumerate(holes):
+            holes[pos] = affine_transform(ring, matrix)
+        return type(geom)(shell, holes)
+    elif geom.type.startswith('Multi') or geom.type == 'GeometryCollection':
+        return type(geom)([affine_transform(part, matrix) for part in geom.geoms])
+    else:
+        raise ValueError('Type %r not recognized' % geom.type)

Shapely-1.5.4/VERSION.txt

@@ -1 +0,0 @@
-1.5.4

Shapely-1.5.4/shapely/__init__.py

@@ -1 +0,0 @@
-__version__ = "1.5.4"

{Shapely-1.5.4 → Shapely-1.5.5}/setup.cfg

@@ -1,5 +1,5 @@
 [egg_info]
+tag_build = 
 tag_date = 0
 tag_svn_revision = 0
-tag_build =