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

shapely/geometry/base.py

@@ -1,24 +1,24 @@
 """Base geometry class and utilities
 """
 
+from ctypes import pointer, c_size_t, c_char_p, c_void_p
 import sys
 import warnings
 
 from shapely.coords import CoordinateSequence
 from shapely.ftools import wraps
-from shapely.geos import lgeos
+from shapely.geos import lgeos, ReadingError
 from shapely.impl import DefaultImplementation, delegated
-from shapely import wkb, wkt
 
 GEOMETRY_TYPES = [
     'Point',
-	'LineString',
-	'LinearRing',
-	'Polygon',
-	'MultiPoint',
-	'MultiLineString',
-	'MultiPolygon',
-	'GeometryCollection'
+    'LineString',
+    'LinearRing',
+    'Polygon',
+    'MultiPoint',
+    'MultiLineString',
+    'MultiPolygon',
+    'GeometryCollection'
     ]
 
 def geometry_type_name(g):
@@ -34,9 +34,9 @@ def geom_factory(g, parent=None):
     geom_type = geometry_type_name(g)
     # TODO: check cost of dynamic import by profiling
     mod = __import__(
-        'shapely.geometry', 
-        globals(), 
-        locals(), 
+        'shapely.geometry',
+        globals(),
+        locals(),
         [geom_type],
         )
     ob.__class__ = getattr(mod, geom_type)
@@ -48,6 +48,34 @@ def geom_factory(g, parent=None):
         ob._ndim = 2
     return ob
 
+def geom_from_wkt(data):
+    geom = lgeos.GEOSGeomFromWKT(c_char_p(data))
+    if not geom:
+        raise ReadingError, \
+        "Could not create geometry because of errors while reading input."
+    return geom_factory(geom)
+
+def geom_to_wkt(ob):
+    if ob is None or ob._geom is None:
+        raise ValueError("Null geometry supports no operations")
+    return lgeos.GEOSGeomToWKT(ob._geom)
+
+def deserialize_wkb(data):
+    geom = lgeos.GEOSGeomFromWKB_buf(c_char_p(data), c_size_t(len(data)));
+    if not geom:
+        raise ReadingError(
+            "Could not create geometry because of errors while reading input.")
+    return geom
+
+def geom_from_wkb(data):
+    return geom_factory(deserialize_wkb(data))
+
+def geom_to_wkb(ob):
+    if ob is None or ob._geom is None:
+        raise ValueError("Null geometry supports no operations")
+    size = c_size_t()
+    return lgeos.GEOSGeomToWKB_buf(c_void_p(ob._geom), pointer(size))
+
 def exceptNull(func):
     """Decorator which helps avoid GEOS operations on null pointers."""
     @wraps(func)
@@ -57,7 +85,17 @@ def exceptNull(func):
         return func(*args, **kwargs)
     return wrapper
 
-EMPTY = wkb.deserialize('010700000000000000'.decode('hex'))
+class CAP_STYLE(object):
+    round = 1
+    flat = 2
+    square = 3
+
+class JOIN_STYLE(object):
+    round = 1
+    mitre = 2
+    bevel = 3
+
+EMPTY = deserialize_wkb('010700000000000000'.decode('hex'))
 
 class BaseGeometry(object):
     """
@@ -89,7 +127,7 @@ class BaseGeometry(object):
     _ndim = None
     _crs = None
     _owned = False
-    
+
     # Backend config
     impl = DefaultImplementation
 
@@ -124,8 +162,12 @@ class BaseGeometry(object):
 
     def __setstate__(self, state):
         self.empty()
-        self.__geom__ = wkb.deserialize(state)
-    
+        self.__geom__ = deserialize_wkb(state)
+        if lgeos.methods['has_z'](self.__geom__):
+            self._ndim = 3
+        else:
+            self._ndim = 2
+
     # The _geom property
     def _get_geom(self):
         return self.__geom__
@@ -134,6 +176,21 @@ class BaseGeometry(object):
         self.__geom__ = val
     _geom = property(_get_geom, _set_geom)
 
+    # Operators
+    # ---------
+
+    def __and__(self, other):
+        return self.intersection(other)
+
+    def __or__(self, other):
+        return self.union(other)
+
+    def __sub__(self, other):
+        return self.difference(other)
+
+    def __xor__(self, other):
+        return self.symmetric_difference(other)
+
     # Array and ctypes interfaces
     # ---------------------------
 
@@ -194,18 +251,18 @@ class BaseGeometry(object):
 
     def geometryType(self):
         return geometry_type_name(self._geom)
-    
+
     @property
     def type(self):
         return self.geometryType()
 
     def to_wkb(self):
-        return wkb.dumps(self)
+        return geom_to_wkb(self)
 
     def to_wkt(self):
-        return wkt.dumps(self)
+        return geom_to_wkt(self)
 
-    geom_type = property(geometryType, 
+    geom_type = property(geometryType,
         doc="""Name of the geometry's type, such as 'Point'"""
         )
     wkt = property(to_wkt,
@@ -236,7 +293,7 @@ class BaseGeometry(object):
     @property
     def boundary(self):
         """Returns a lower dimension geometry that bounds the object
-        
+
         The boundary of a polygon is a line, the boundary of a line is a
         collection of points. The boundary of a point is an empty (null)
         collection.
@@ -250,7 +307,7 @@ class BaseGeometry(object):
             return ()
         else:
             return self.impl['bounds'](self)
-            
+
     @property
     def centroid(self):
         """Returns the geometric center of the object"""
@@ -263,12 +320,12 @@ class BaseGeometry(object):
 
     @property
     def convex_hull(self):
-        """Imagine an elastic band stretched around the geometry: that's a 
+        """Imagine an elastic band stretched around the geometry: that's a
         convex hull, more or less
 
         The convex hull of a three member multipoint, for example, is a
         triangular polygon.
-        """ 
+        """
         return geom_factory(self.impl['convex_hull'](self))
 
     @property
@@ -276,16 +333,32 @@ class BaseGeometry(object):
         """A figure that envelopes the geometry"""
         return geom_factory(self.impl['envelope'](self))
 
-    def buffer(self, distance, resolution=16, quadsegs=None):
-        """Returns a geometry with an envelope at a distance from the object's 
+    def buffer(self, distance, resolution=16, quadsegs=None,
+               cap_style=CAP_STYLE.round, join_style=JOIN_STYLE.round,
+               mitre_limit=0):
+        """Returns a geometry with an envelope at a distance from the object's
         envelope
-        
+
         A negative distance has a "shrink" effect. A zero distance may be used
         to "tidy" a polygon. The resolution of the buffer around each vertex of
         the object increases by increasing the resolution keyword parameter
         or second positional parameter. Note: the use of a `quadsegs` parameter
         is deprecated and will be gone from the next major release.
 
+        The styles of caps are: CAP_STYLE.round (1), CAP_STYLE.flat (2), and
+        CAP_STYLE.square (3).
+
+        The styles of joins between offset segments are: JOIN_STYLE.round (1),
+        JOIN_STYLE.mitre (2), and JOIN_STYLE.bevel (3).
+
+        The mitre limit ratio is used for very sharp corners. The mitre ratio
+        is the ratio of the distance from the corner to the end of the mitred
+        offset corner. When two line segments meet at a sharp angle, a miter
+        join will extend the original geometry. To prevent unreasonable
+        geometry, the mitre limit allows controlling the maximum length of the
+        join corner. Corners with a ratio which exceed the limit will be
+        beveled.
+
         Example:
 
           >>> from shapely.wkt import loads
@@ -296,19 +369,35 @@ class BaseGeometry(object):
           3.1415138011443009
           >>> g.buffer(1.0, 3).area     # triangle approximation
           3.0
+          >>> list(g.buffer(1.0, cap_style='square').exterior.coords)
+          [(1.0, 1.0), (1.0, -1.0), (-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0)]
+          >>> g.buffer(1.0, cap_style='square').area
+          4.0
         """
+
         if quadsegs is not None:
             warnings.warn(
-                "The `quadsegs` argument is deprecated. Use `resolution`.", 
+                "The `quadsegs` argument is deprecated. Use `resolution`.",
                 DeprecationWarning)
             res = quadsegs
         else:
             res = resolution
-        return geom_factory(self.impl['buffer'](self, distance, res))
+
+        if cap_style == CAP_STYLE.round and join_style == JOIN_STYLE.round:
+            return geom_factory(self.impl['buffer'](self, distance, res))
+
+        if 'buffer_with_style' not in self.impl:
+            raise NotImplementedError("Styled buffering not available for "
+                                      "GEOS versions < 3.2.")
+
+        return geom_factory(self.impl['buffer_with_style'](self, distance, res,
+                                                           cap_style,
+                                                           join_style,
+                                                           mitre_limit))
 
     @delegated
     def simplify(self, tolerance, preserve_topology=True):
-        """Returns a simplified geometry produced by the Douglas-Puecker 
+        """Returns a simplified geometry produced by the Douglas-Puecker
         algorithm
 
         Coordinates of the simplified geometry will be no more than the
@@ -328,13 +417,13 @@ class BaseGeometry(object):
     def difference(self, other):
         """Returns the difference of the geometries"""
         return geom_factory(self.impl['difference'](self, other))
-    
+
     def intersection(self, other):
         """Returns the intersection of the geometries"""
         return geom_factory(self.impl['intersection'](self, other))
 
     def symmetric_difference(self, other):
-        """Returns the symmetric difference of the geometries 
+        """Returns the symmetric difference of the geometries
         (Shapely geometry)"""
         return geom_factory(self.impl['symmetric_difference'](self, other))
 
@@ -354,7 +443,7 @@ class BaseGeometry(object):
     @property
     def is_empty(self):
         """True if the set of points in this geometry is empty, else False"""
-        return bool(self.impl['is_empty'](self)) or (self._geom is None)
+        return (self._geom is None) or bool(self.impl['is_empty'](self))
 
     @property
     def is_ring(self):
@@ -363,13 +452,13 @@ class BaseGeometry(object):
 
     @property
     def is_simple(self):
-        """True if the geometry is simple, meaning that any self-intersections 
+        """True if the geometry is simple, meaning that any self-intersections
         are only at boundary points, else False"""
         return bool(self.impl['is_simple'](self))
 
     @property
     def is_valid(self):
-        """True if the geometry is valid (definition depends on sub-class), 
+        """True if the geometry is valid (definition depends on sub-class),
         else False"""
         return bool(self.impl['is_valid'](self))
 
@@ -377,7 +466,7 @@ class BaseGeometry(object):
     # -----------------
 
     def relate(self, other):
-        """Returns the DE-9IM intersection matrix for the two geometries 
+        """Returns the DE-9IM intersection matrix for the two geometries
         (string)"""
         return self.impl['relate'](self, other)
 
@@ -414,13 +503,13 @@ class BaseGeometry(object):
         return bool(self.impl['within'](self, other))
 
     def equals_exact(self, other, tolerance):
-        """Returns True if geometries are equal to within a specified 
+        """Returns True if geometries are equal to within a specified
         tolerance"""
         # return BinaryPredicateOp('equals_exact', self)(other, tolerance)
         return bool(self.impl['equals_exact'](self, other, tolerance))
 
     def almost_equals(self, other, decimal=6):
-        """Returns True if geometries are equal at all coordinates to a 
+        """Returns True if geometries are equal at all coordinates to a
         specified decimal place"""
         return self.equals_exact(other, 0.5 * 10**(-decimal))
 
@@ -429,22 +518,22 @@ class BaseGeometry(object):
 
     @delegated
     def project(self, other, normalized=False):
-        """Returns the distance along this geometry to a point nearest the 
+        """Returns the distance along this geometry to a point nearest the
         specified point
-        
+
         If the normalized arg is True, return the distance normalized to the
         length of the linear geometry.
-        """ 
+        """
         if normalized:
             op = self.impl['project_normalized']
         else:
             op = self.impl['project']
         return op(self, other)
-           
+
     @delegated
     def interpolate(self, distance, normalized=False):
         """Return a point at the specified distance along a linear geometry
-        
+
         If the normalized arg is True, the distance will be interpreted as a
         fraction of the geometry's length.
         """
@@ -537,7 +626,7 @@ class GeometrySequence(object):
     def _update(self):
         self._geom = self.__p__._geom
         self._ndim = self.__p__._ndim
-        
+
     def _get_geom_item(self, i):
         g = self.shape_factory()
         g._owned = True
@@ -548,23 +637,35 @@ class GeometrySequence(object):
 
     def __iter__(self):
         self._update()
-        for i in range(self.__len__()):
+        for i in xrange(self.__len__()):
             yield self._get_geom_item(i)
 
     def __len__(self):
         self._update()
         return lgeos.GEOSGetNumGeometries(self._geom)
 
-    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
+        m = self.__len__()
+        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
+            return self._get_geom_item(i)
+        elif isinstance(key, slice):
+            if type(self) == HeterogeneousGeometrySequence:
+                raise TypeError(
+                    "Heterogenous geometry collections are not sliceable")
+            res = []
+            start, stop, stride = key.indices(m)
+            for i in xrange(start, stop, stride):
+                res.append(self._get_geom_item(i))
+            return type(self.__p__)(res or None)
         else:
-            ii = i
-        return self._get_geom_item(i)
+            raise TypeError("key must be an index or slice")
 
     @property
     def _longest(self):
@@ -585,7 +686,7 @@ class HeterogeneousGeometrySequence(GeometrySequence):
 
     def _get_geom_item(self, i):
         sub = lgeos.GEOSGetGeometryN(self._geom, i)
-        g = geom_factory(sub)
+        g = geom_factory(sub, parent=self)
         g._owned = True
         return g
 

shapely/geometry/geo.py

@@ -11,14 +11,14 @@ from multipolygon import MultiPolygon, MultiPolygonAdapter
 
 
 def box(minx, miny, maxx, maxy, ccw=True):
-    """Return a rectangular polygon with configurable normal vector"""
+    """Returns a rectangular polygon with configurable normal vector"""
     coords = [(maxx, miny), (maxx, maxy), (minx, maxy), (minx, miny)]
     if not ccw:
         coords = coords[::-1]
     return Polygon(coords)
 
 def shape(context):
-    """Return a new, independent geometry with coordinates *copied* from the
+    """Returns a new, independent geometry with coordinates *copied* from the
     context.
     """
     if hasattr(context, "__geo_interface__"):

shapely/geometry/linestring.py

@@ -4,8 +4,9 @@
 from ctypes import c_double, cast, POINTER
 from ctypes import ArgumentError
 
+from shapely.coords import required
 from shapely.geos import lgeos, TopologicalError
-from shapely.geometry.base import BaseGeometry, geom_factory
+from shapely.geometry.base import BaseGeometry, geom_factory, JOIN_STYLE
 from shapely.geometry.proxy import CachingGeometryProxy
 
 __all__ = ['LineString', 'asLineString']
@@ -14,7 +15,7 @@ __all__ = ['LineString', 'asLineString']
 class LineString(BaseGeometry):
     """
     A one-dimensional figure comprising one or more line segments
-    
+
     A LineString has non-zero length and zero area. It may approximate a curve
     and need not be straight. Unlike a LinearRing, a LineString is not closed.
     """
@@ -56,7 +57,7 @@ class LineString(BaseGeometry):
     def array_interface(self):
         """Provide the Numpy array protocol."""
         return self.coords.array_interface()
-    
+
     __array_interface__ = property(array_interface)
 
     # Coordinate access
@@ -69,9 +70,9 @@ class LineString(BaseGeometry):
     @property
     def xy(self):
         """Separate arrays of X and Y coordinate values
-        
+
         Example:
-        
+
           >>> x, y = LineString(((0, 0), (1, 1))).xy
           >>> list(x)
           [0.0, 1.0]
@@ -79,22 +80,23 @@ class LineString(BaseGeometry):
           [0.0, 1.0]
         """
         return self.coords.xy
-    
+
     def parallel_offset(
-        self, distance, side, 
-        resolution=16, join_style=1, mitre_limit=1.0):
-        
+        self, distance, side,
+        resolution=16, join_style=JOIN_STYLE.round, mitre_limit=1.0):
+
         """Returns a LineString or MultiLineString geometry at a distance from
         the object on its right or its left side.
-        
+
         Distance must be a positive float value. The side parameter may be
         'left' or 'right'. The resolution of the buffer around each vertex of
         the object increases by increasing the resolution keyword parameter or
         third positional parameter.
-        
+
         The join style is for outside corners between line segments. Accepted
-        values are 1 => ROUND, 2 => MITRE, 3 => BEVEL.
-        
+        values are JOIN_STYLE.round (1), JOIN_STYLE.mitre (2), and
+        JOIN_STYLE.bevel (3).
+
         The mitre ratio limit is used for very sharp corners. It is the ratio
         of the distance from the corner to the end of the mitred offset corner.
         When two line segments meet at a sharp angle, a miter join will extend
@@ -104,11 +106,11 @@ class LineString(BaseGeometry):
 
         try:
             return geom_factory(self.impl['parallel_offset'](
-                self, distance, resolution, join_style, mitre_limit, 
+                self, distance, resolution, join_style, mitre_limit,
                 bool(side=='left')))
         except WindowsError:
             raise TopologicalError()
-        
+
 
 class LineStringAdapter(CachingGeometryProxy, LineString):
 
@@ -151,6 +153,9 @@ def asLineString(context):
 
 
 def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
+    # 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__
@@ -194,7 +199,7 @@ def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
                 except IndexError:
                     raise ValueError("Inconsistent coordinate dimensionality")
 
-            # Because of a bug in the GEOS C API, 
+            # Because of a bug in the GEOS C API,
             # always set X before Y
             lgeos.GEOSCoordSeq_setX(cs, i, dx)
             lgeos.GEOSCoordSeq_setY(cs, i, dy)
@@ -223,11 +228,11 @@ def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
                 % update_ndim)
         else:
             cs = lgeos.GEOSCoordSeq_create(m, n)
-        
+
         # add to coordinate sequence
         for i in xrange(m):
             coords = ob[i]
-            # Because of a bug in the GEOS C API, 
+            # Because of a bug in the GEOS C API,
             # always set X before Y
             lgeos.GEOSCoordSeq_setX(cs, i, coords[0])
             lgeos.GEOSCoordSeq_setY(cs, i, coords[1])
@@ -236,7 +241,7 @@ def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
                     lgeos.GEOSCoordSeq_setZ(cs, i, coords[2])
                 except IndexError:
                     raise ValueError("Inconsistent coordinate dimensionality")
-    
+
     if update_geom is not None:
         return None
     else:

shapely/geometry/multilinestring.py

@@ -40,8 +40,8 @@ class MultiLineString(BaseMultipartGeometry):
         """
         super(MultiLineString, self).__init__()
 
-        if lines is None:
-            # allow creation of null lines, to support unpickling
+        if not lines:
+            # allow creation of empty multilinestrings, to support unpickling
             pass
         else:
             self._geom, self._ndim = geos_multilinestring_from_py(lines)

shapely/geometry/multipoint.py

@@ -4,6 +4,7 @@
 from ctypes import byref, c_double, c_void_p, cast, POINTER
 from ctypes import ArgumentError
 
+from shapely.coords import required
 from shapely.geos import lgeos
 from shapely.geometry.base import BaseMultipartGeometry, exceptNull
 from shapely.geometry.point import Point, geos_point_from_py
@@ -128,6 +129,9 @@ def asMultiPoint(context):
 
 
 def geos_multipoint_from_py(ob):
+    # 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__

shapely/geometry/multipolygon.py

@@ -50,8 +50,8 @@ class MultiPolygon(BaseMultipartGeometry):
         """
         super(MultiPolygon, self).__init__()
 
-        if polygons is None:
-            # allow creation of null collections, to support unpickling
+        if not polygons:
+            # allow creation of empty multipolygons, to support unpickling
             pass
         elif context_type == 'polygons':
             self._geom, self._ndim = geos_multipolygon_from_polygons(polygons)
@@ -69,7 +69,7 @@ class MultiPolygon(BaseMultipartGeometry):
             coords.append(tuple(geom.exterior.coords))
             for hole in geom.interiors:
                 coords.append(tuple(hole.coords))
-            allcoords.append(coords)
+            allcoords.append(tuple(coords))
         return {
             'type': 'MultiPolygon',
             'coordinates': allcoords
@@ -109,8 +109,9 @@ def asMultiPolygon(context):
 def geos_multipolygon_from_py(ob):
     """ob must provide Python geo interface coordinates."""
     L = len(ob)
-    N = len(ob[0][0][0])
     assert L >= 1
+    
+    N = len(ob[0][0][0])
     assert N == 2 or N == 3
 
     subs = (c_void_p * L)()
@@ -124,12 +125,14 @@ def geos_multipolygon_from_polygons(ob):
     """ob must be either a sequence or array of sequences or arrays."""
     obs = getattr(ob, 'geoms', None) or ob
     L = len(obs)
+    assert L >= 1
+    
     exemplar = obs[0]
     try:
         N = len(exemplar[0][0])
     except TypeError:
         N = exemplar._ndim
-    assert L >= 1
+    
     assert N == 2 or N == 3
 
     subs = (c_void_p * L)()