shapely 1.2.13__py2.6-win-amd64.egg → 1.2.18__py2.6-win-amd64.egg

EGG-INFO/native_libs.txt

@@ -1 +1,3 @@
+shapely/DLLs/geos.dll
+shapely/DLLs/geos_c.dll
 shapely/speedups/_speedups.pyd

EGG-INFO/not-zip-safe

@@ -1 +1 @@
-
+

shapely/__init__.py

@@ -1,2 +1 @@
-__version__ = "1.2.13"
-
+__version__ = "1.2.18"

shapely/affinity.py

@@ -0,0 +1,252 @@
+"""Affine transforms, both in general and specific, named transforms."""
+
+from math import sin, cos, tan, pi
+
+__all__ = ['affine_transform', 'rotate', 'scale', 'skew', 'translate']
+
+
+def affine_transform(geom, matrix):
+    """Returns a transformed geometry using an affine transformation matrix.
+
+    The coefficient matrix is provided as a list or tuple with 6 or 12 items
+    for 2D or 3D transformations, respectively.
+
+    For 2D affine transformations, the 6 parameter matrix is:
+
+        [a, b, d, e, xoff, yoff]
+
+    which represents the augmented matrix:
+
+                            / a  b xoff \ 
+        [x' y' 1] = [x y 1] | d  e yoff |
+                            \ 0  0   1  /
+
+    or the equations for the transformed coordinates:
+
+        x' = a * x + b * y + xoff
+        y' = d * x + e * y + yoff
+
+    For 3D affine transformations, the 12 parameter matrix is:
+
+        [a, b, c, d, e, f, g, h, i, xoff, yoff, zoff]
+
+    which represents the augmented matrix:
+
+                                 / a  b  c xoff \ 
+        [x' y' z' 1] = [x y z 1] | d  e  f yoff |
+                                 | g  h  i zoff |
+                                 \ 0  0  0   1  /
+
+    or the equations for the transformed coordinates:
+
+        x' = a * x + b * y + c * z + xoff
+        y' = d * x + e * y + f * z + yoff
+        z' = g * x + h * y + i * z + zoff
+    """
+    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")
+
+    def affine_pts(pts):
+        """Internal function to yield affine transform of coordinate tuples"""
+        if ndim == 2:
+            for x, y in pts:
+                xp = a * x + b * y + xoff
+                yp = d * x + e * y + yoff
+                yield (xp, yp)
+        elif ndim == 3:
+            for x, y, z in pts:
+                xp = a * x + b * y + c * z + xoff
+                yp = d * x + e * y + f * z + yoff
+                zp = g * x + h * y + i * z + zoff
+                yield (xp, yp, zp)
+
+    # Process coordinates from each supported geometry type
+    if geom.type in ('Point', 'LineString'):
+        return type(geom)(list(affine_pts(geom.coords)))
+    elif geom.type == 'Polygon':
+        ring = geom.exterior
+        shell = type(ring)(list(affine_pts(ring.coords)))
+        holes = list(geom.interiors)
+        for pos, ring in enumerate(holes):
+            holes[pos] = type(ring)(list(affine_pts(ring.coords)))
+        return type(geom)(shell, holes)
+    elif geom.type.startswith('Multi') or geom.type == 'GeometryCollection':
+        # Recursive call
+        # TODO: fix GeometryCollection constructor
+        return type(geom)([affine_transform(part, matrix) for part in geom.geoms])
+    else:
+        raise ValueError('Type %r not recognized' % geom.type)
+
+
+def interpret_origin(geom, origin, ndim):
+    """Returns interpreted coordinate tuple for origin parameter.
+
+    This is a helper function for other transform functions.
+
+    The point of origin can be a keyword 'center' for the 2D bounding box
+    center, 'centroid' for the geometry's 2D centroid, a Point object or a
+    coordinate tuple (x0, y0, z0).
+    """
+    # get coordinate tuple from 'origin' from keyword or Point type
+    if origin == 'center':
+        # bounding box center
+        minx, miny, maxx, maxy = geom.bounds
+        origin = ((maxx + minx)/2.0, (maxy + miny)/2.0)
+    elif origin == 'centroid':
+        origin = geom.centroid.coords[0]
+    elif isinstance(origin, str):
+        raise ValueError("'origin' keyword %r is not recognized" % origin)
+    elif hasattr(origin, 'type') and origin.type == 'Point':
+        origin = origin.coords[0]
+
+    # origin should now be tuple-like
+    if len(origin) not in (2, 3):
+        raise ValueError("Expected number of items in 'origin' to be "
+                         "either 2 or 3")
+    if ndim == 2:
+        return origin[0:2]
+    else:  # 3D coordinate
+        if len(origin) == 2:
+            return origin + (0.0,)
+        else:
+            return origin
+
+
+def rotate(geom, angle, origin='center', use_radians=False):
+    """Returns a rotated geometry on a 2D plane.
+
+    The angle of rotation can be specified in either degrees (default) or
+    radians by setting ``use_radians=True``. Positive angles are
+    counter-clockwise and negative are clockwise rotations.
+
+    The point of origin can be a keyword 'center' for the bounding box
+    center (default), 'centroid' for the geometry's centroid, a Point object
+    or a coordinate tuple (x0, y0).
+
+    The affine transformation matrix for 2D rotation is:
+
+      / cos(r) -sin(r) xoff \ 
+      | sin(r)  cos(r) yoff |
+      \   0       0      1  /
+
+    where the offsets are calculated from the origin Point(x0, y0):
+
+        xoff = x0 - x0 * cos(r) + y0 * sin(r)
+        yoff = y0 - x0 * sin(r) - y0 * cos(r)
+    """
+    if not use_radians:  # convert from degrees
+        angle *= pi/180.0
+    cosp = cos(angle)
+    sinp = sin(angle)
+    if abs(cosp) < 2.5e-16:
+        cosp = 0.0
+    if abs(sinp) < 2.5e-16:
+        sinp = 0.0
+    x0, y0 = interpret_origin(geom, origin, 2)
+
+    matrix = (cosp, -sinp, 0.0,
+              sinp,  cosp, 0.0,
+              0.0,    0.0, 1.0,
+              x0 - x0 * cosp + y0 * sinp, y0 - x0 * sinp - y0 * cosp, 0.0)
+    return affine_transform(geom, matrix)
+
+
+def scale(geom, xfact=1.0, yfact=1.0, zfact=1.0, origin='center'):
+    """Returns a scaled geometry, scaled by factors along each dimension.
+
+    The point of origin can be a keyword 'center' for the 2D bounding box
+    center (default), 'centroid' for the geometry's 2D centroid, a Point
+    object or a coordinate tuple (x0, y0, z0).
+
+    Negative scale factors will mirror or reflect coordinates.
+
+    The general 3D affine transformation matrix for scaling is:
+
+        / xfact  0    0   xoff \ 
+        |   0  yfact  0   yoff |
+        |   0    0  zfact zoff |
+        \   0    0    0     1  /
+
+    where the offsets are calculated from the origin Point(x0, y0, z0):
+
+        xoff = x0 - x0 * xfact
+        yoff = y0 - y0 * yfact
+        zoff = z0 - z0 * zfact
+    """
+    x0, y0, z0 = interpret_origin(geom, origin, 3)
+
+    matrix = (xfact, 0.0, 0.0,
+              0.0, yfact, 0.0,
+              0.0, 0.0, zfact,
+              x0 - x0 * xfact, y0 - y0 * yfact, z0 - z0 * zfact)
+    return affine_transform(geom, matrix)
+
+
+def skew(geom, xs=0.0, ys=0.0, origin='center', use_radians=False):
+    """Returns a skewed geometry, sheared by angles along x and y dimensions.
+
+    The shear angle can be specified in either degrees (default) or radians
+    by setting ``use_radians=True``.
+
+    The point of origin can be a keyword 'center' for the bounding box
+    center (default), 'centroid' for the geometry's centroid, a Point object
+    or a coordinate tuple (x0, y0).
+
+    The general 2D affine transformation matrix for skewing is:
+
+        /   1    tan(xs) xoff \ 
+        | tan(ys)  1     yoff |
+        \   0      0       1  /
+
+    where the offsets are calculated from the origin Point(x0, y0):
+
+        xoff = -y0 * tan(xs)
+        yoff = -x0 * tan(ys)
+    """
+    if not use_radians:  # convert from degrees
+        xs *= pi/180.0
+        ys *= pi/180.0
+    tanx = tan(xs)
+    tany = tan(ys)
+    if abs(tanx) < 2.5e-16:
+        tanx = 0.0
+    if abs(tany) < 2.5e-16:
+        tany = 0.0
+    x0, y0 = interpret_origin(geom, origin, 2)
+
+    matrix = (1.0, tanx, 0.0,
+              tany, 1.0, 0.0,
+              0.0,  0.0, 1.0,
+              -y0 * tanx, -x0 * tany, 0.0)
+    return affine_transform(geom, matrix)
+
+
+def translate(geom, xoff=0.0, yoff=0.0, zoff=0.0):
+    """Returns a translated geometry shifted by offsets along each dimension.
+
+    The general 3D affine transformation matrix for translation is:
+
+        / 1  0  0 xoff \ 
+        | 0  1  0 yoff |
+        | 0  0  1 zoff |
+        \ 0  0  0   1  /
+    """
+    matrix = (1.0, 0.0, 0.0,
+              0.0, 1.0, 0.0,
+              0.0, 0.0, 1.0,
+              xoff, yoff, zoff)
+    return affine_transform(geom, matrix)

shapely/coords.py

@@ -8,6 +8,21 @@ import sys
 from shapely.geos import lgeos
 from shapely.topology import Validating
 
+try:
+    import numpy
+    has_numpy = True
+except ImportError:
+    has_numpy = False
+
+def required(ob):
+    """Return an object that meets Shapely requirements for self-owned
+    C-continguous data, copying if necessary, or just return the original
+    object."""
+    if has_numpy and hasattr(ob, '__array_interface__'):
+        return numpy.require(ob, numpy.float64, ["C", "OWNDATA"])
+    else:
+        return ob
+
 
 class CoordinateSequence(object):
     """
@@ -30,7 +45,7 @@ class CoordinateSequence(object):
     # _ndim : int
     #     Number of dimensions (2 or 3, generally)
     # __p__ : object
-    #     Parent (Shapely) geometry    
+    #     Parent (Shapely) geometry
     _cseq = None
     _ndim = None
     __p__ = None
@@ -41,7 +56,7 @@ class CoordinateSequence(object):
     def _update(self):
         self._ndim = self.__p__._ndim
         self._cseq = lgeos.GEOSGeom_getCoordSeq(self.__p__._geom)
-    
+
     def __len__(self):
         self._update()
         cs_len = c_uint(0)
@@ -53,38 +68,56 @@ class CoordinateSequence(object):
         dx = c_double()
         dy = c_double()
         dz = c_double()
-        for i in range(self.__len__()):
+        has_z = self._ndim == 3
+        for i in xrange(self.__len__()):
             lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(dx))
             lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(dy))
-            if self._ndim == 3: # TODO: use hasz
+            if has_z:
                 lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(dz))
                 yield (dx.value, dy.value, dz.value)
             else:
                 yield (dx.value, dy.value)
 
-    def __getitem__(self, i):
+    def __getitem__(self, key):
         self._update()
-        M = self.__len__()
-        if i + M < 0 or i >= M:
-            raise IndexError("index out of range")
-        if i < 0:
-            ii = M + i
-        else:
-            ii = i
         dx = c_double()
         dy = c_double()
         dz = c_double()
-        lgeos.GEOSCoordSeq_getX(self._cseq, ii, byref(dx))
-        lgeos.GEOSCoordSeq_getY(self._cseq, ii, byref(dy))
-        if self._ndim == 3: # TODO: use hasz
-            lgeos.GEOSCoordSeq_getZ(self._cseq, ii, byref(dz))
-            return (dx.value, dy.value, dz.value)
+        m = self.__len__()
+        has_z = self._ndim == 3
+        if isinstance(key, int):
+            if key + m < 0 or key >= m:
+                raise IndexError("index out of range")
+            if key < 0:
+                i = m + key
+            else:
+                i = key
+            lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(dx))
+            lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(dy))
+            if has_z:
+                lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(dz))
+                return (dx.value, dy.value, dz.value)
+            else:
+                return (dx.value, dy.value)
+        elif isinstance(key, slice):
+            res = []
+            start, stop, stride = key.indices(m)
+            for i in xrange(start, stop, stride):
+                lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(dx))
+                lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(dy))
+                if has_z:
+                    lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(dz))
+                    res.append((dx.value, dy.value, dz.value))
+                else:
+                    res.append((dx.value, dy.value))
+            return res
         else:
-            return (dx.value, dy.value)
+            raise TypeError("key must be an index or slice")
 
     @property
     def ctypes(self):
         self._update()
+        has_z = self._ndim == 3
         n = self._ndim
         m = self.__len__()
         array_type = c_double * (m * n)
@@ -95,7 +128,7 @@ class CoordinateSequence(object):
             data[n*i] = temp.value
             lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(temp))
             data[n*i+1] = temp.value
-            if n == 3: # TODO: use hasz
+            if has_z:
                 lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(temp))
                 data[n*i+2] = temp.value
         return data
@@ -133,7 +166,7 @@ class CoordinateSequence(object):
             lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(temp))
             y.append(temp.value)
         return x, y
-            
+
 
 class BoundsOp(Validating):
 
@@ -163,4 +196,3 @@ class BoundsOp(Validating):
             if y < miny: miny = y
             if y > maxy: maxy = y
         return (minx, miny, maxx, maxy)
-

shapely/ctypes_declarations.py

@@ -100,6 +100,11 @@ def prototype(lgeos, geosVersion):
     lgeos.GEOSBuffer.restype = ctypes.c_void_p
     lgeos.GEOSBuffer.argtypes = [ctypes.c_void_p, ctypes.c_double, ctypes.c_int]
 
+    lgeos.GEOSBufferWithStyle.restype = ctypes.c_void_p
+    lgeos.GEOSBufferWithStyle.argtypes = [ctypes.c_void_p, ctypes.c_double,
+                                          ctypes.c_int, ctypes.c_int,
+                                          ctypes.c_int, ctypes.c_double]
+
     lgeos.GEOSSimplify.restype = ctypes.c_void_p
     lgeos.GEOSSimplify.argtypes = [ctypes.c_void_p, ctypes.c_double]
 
@@ -271,14 +276,22 @@ def prototype(lgeos, geosVersion):
             lgeos.GEOSProject.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
 
             lgeos.GEOSProjectNormalized.restype = ctypes.c_double
-            lgeos.GEOSProjectNormalized.argtypes = [ctypes.c_void_p, 
+            lgeos.GEOSProjectNormalized.argtypes = [ctypes.c_void_p,
                                                     ctypes.c_void_p]
 
             lgeos.GEOSInterpolate.restype = ctypes.c_void_p
-            lgeos.GEOSInterpolate.argtypes = [ctypes.c_void_p, 
+            lgeos.GEOSInterpolate.argtypes = [ctypes.c_void_p,
                                               ctypes.c_double]
 
             lgeos.GEOSInterpolateNormalized.restype = ctypes.c_void_p
-            lgeos.GEOSInterpolateNormalized.argtypes = [ctypes.c_void_p, 
+            lgeos.GEOSInterpolateNormalized.argtypes = [ctypes.c_void_p,
                                                         ctypes.c_double]
 
+    # TODO: Find out what version of geos_c came with geos 3.3.0
+    if geosVersion >= (1, 6, 3):
+        lgeos.GEOSUnaryUnion.restype = ctypes.c_void_p
+        lgeos.GEOSUnaryUnion.argtypes = [ctypes.c_void_p]
+    
+        lgeos.GEOSPolygonize_full.restype = ctypes.c_void_p
+        lgeos.GEOSPolygonize_full.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p]
+

shapely/geometry/__init__.py

@@ -1,10 +1,11 @@
 """Geometry classes and factories
 """
 
+from base import CAP_STYLE, JOIN_STYLE
 from geo import box, shape, asShape, mapping
 from point import Point, asPoint
 from linestring import LineString, asLineString
-from polygon import Polygon, asPolygon
+from polygon import Polygon, asPolygon, LinearRing, asLinearRing
 from multipoint import MultiPoint, asMultiPoint
 from multilinestring import MultiLineString, asMultiLineString
 from multipolygon import MultiPolygon, asMultiPolygon
@@ -14,7 +15,6 @@ __all__ = [
     'box', 'shape', 'asShape', 'Point', 'asPoint', 'LineString', 'asLineString',
     'Polygon', 'asPolygon', 'MultiPoint', 'asMultiPoint',
     'MultiLineString', 'asMultiLineString', 'MultiPolygon', 'asMultiPolygon',
-    'GeometryCollection', 'mapping'
+    'GeometryCollection', 'mapping', 'LinearRing', 'asLinearRing',
+    'CAP_STYLE', 'JOIN_STYLE'
     ]
-
-