shapely 1.3.3__cp34-none-win32.whl

shapely/_geos.pxi

@@ -0,0 +1,52 @@
+# 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
+
+    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
+
+
+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/affinity.py

@@ -0,0 +1,255 @@
+"""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 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")
+
+    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', 'LinearRing'):
+        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/algorithms/cga.py

@@ -0,0 +1,16 @@
+
+def signed_area(ring):
+    """Return the signed area enclosed by a ring in linear time using the 
+    algorithm at: http://www.cgafaq.info/wiki/Polygon_Area.
+    """
+    xs, ys = ring.coords.xy
+    xs.append(xs[1])
+    ys.append(ys[1])
+    return sum(xs[i]*(ys[i+1]-ys[i-1]) for i in range(1, len(ring.coords)))/2.0
+
+def is_ccw_impl(name):
+    """Predicate implementation"""
+    def is_ccw_op(ring):
+        return signed_area(ring) >= 0.0
+    return is_ccw_op
+

shapely/coords.py

@@ -0,0 +1,206 @@
+"""Coordinate sequence utilities
+"""
+
+import sys
+from array import array
+from ctypes import byref, c_double, c_uint
+
+from shapely.geos import lgeos
+from shapely.topology import Validating
+
+if sys.version_info[0] < 3:
+    range = xrange
+
+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 (hasattr(ob, '__array_interface__')
+            and ob.__array_interface__.get('strides')):
+        if has_numpy:
+            return numpy.require(ob, numpy.float64, ["C", "OWNDATA"])
+        else:
+            # raise an error if strided. See issue #52.
+            raise ValueError("C-contiguous data is required")
+    else:
+        return ob
+
+
+class CoordinateSequence(object):
+    """
+    Iterative access to coordinate tuples from the parent geometry's coordinate
+    sequence.
+
+    Example:
+
+      >>> from shapely.wkt import loads
+      >>> g = loads('POINT (0.0 0.0)')
+      >>> list(g.coords)
+      [(0.0, 0.0)]
+
+    """
+
+    # Attributes
+    # ----------
+    # _cseq : c_void_p
+    #     Ctypes pointer to GEOS coordinate sequence
+    # _ndim : int
+    #     Number of dimensions (2 or 3, generally)
+    # __p__ : object
+    #     Parent (Shapely) geometry
+    _cseq = None
+    _ndim = None
+    __p__ = None
+
+    def __init__(self, parent):
+        self.__p__ = parent
+
+    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)
+        lgeos.GEOSCoordSeq_getSize(self._cseq, byref(cs_len))
+        return cs_len.value
+
+    def __iter__(self):
+        self._update()
+        dx = c_double()
+        dy = c_double()
+        dz = c_double()
+        has_z = self._ndim == 3
+        for i in range(self.__len__()):
+            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))
+                yield (dx.value, dy.value, dz.value)
+            else:
+                yield (dx.value, dy.value)
+
+    def __getitem__(self, key):
+        self._update()
+        dx = c_double()
+        dy = c_double()
+        dz = c_double()
+        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 range(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:
+            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)
+        data = array_type()
+        temp = c_double()
+        for i in range(m):
+            lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(temp))
+            data[n*i] = temp.value
+            lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(temp))
+            data[n*i+1] = temp.value
+            if has_z:
+                lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(temp))
+                data[n*i+2] = temp.value
+        return data
+
+    def array_interface(self):
+        """Provide the Numpy array protocol."""
+        if sys.byteorder == 'little':
+            typestr = '<f8'
+        elif sys.byteorder == 'big':
+            typestr = '>f8'
+        else:
+            raise ValueError(
+                "Unsupported byteorder: neither little nor big-endian")
+        ai = {
+            'version': 3,
+            'typestr': typestr,
+            'data': self.ctypes,
+            }
+        ai.update({'shape': (len(self), self._ndim)})
+        return ai
+    
+    __array_interface__ = property(array_interface)
+    
+    @property
+    def xy(self):
+        """X and Y arrays"""
+        self._update()
+        m = self.__len__()
+        x = array('d')
+        y = array('d')
+        temp = c_double()
+        for i in range(m):
+            lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(temp))
+            x.append(temp.value)
+            lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(temp))
+            y.append(temp.value)
+        return x, y
+
+
+class BoundsOp(Validating):
+
+    def __init__(self, *args):
+        pass
+
+    def __call__(self, this):
+        self._validate(this)
+        env = this.envelope
+        if env.geom_type == 'Point':
+            return env.bounds
+        cs = lgeos.GEOSGeom_getCoordSeq(env.exterior._geom)
+        cs_len = c_uint(0)
+        lgeos.GEOSCoordSeq_getSize(cs, byref(cs_len))
+        minx = 1.e+20
+        maxx = -1e+20
+        miny = 1.e+20
+        maxy = -1e+20
+        temp = c_double()
+        for i in range(cs_len.value):
+            lgeos.GEOSCoordSeq_getX(cs, i, byref(temp))
+            x = temp.value
+            if x < minx: minx = x
+            if x > maxx: maxx = x
+            lgeos.GEOSCoordSeq_getY(cs, i, byref(temp))
+            y = temp.value
+            if y < miny: miny = y
+            if y > maxy: maxy = y
+        return (minx, miny, maxx, maxy)