shapely 1.2.14__py2.7-win-amd64.egg → 1.2.18__py2.7-win-amd64.egg

shapely/geos.py

@@ -42,7 +42,7 @@ def load_dll(libname, fallbacks=None):
         raise OSError(
             "Could not find library %s or load any of its variants %s" % (
                 libname, fallbacks or []))
-       
+
 if sys.platform.startswith('linux'):
     _lgeos = load_dll('geos_c', fallbacks=['libgeos_c.so.1', 'libgeos_c.so'])
     free = load_dll('c').free
@@ -64,7 +64,7 @@ elif sys.platform == 'darwin':
 elif sys.platform == 'win32':
     try:
         egg_dlls = os.path.abspath(os.path.join(os.path.dirname(__file__),
-                                   r"..\DLLs"))
+                                     r"DLLs"))
         wininst_dlls =  os.path.abspath(os.__file__ + "../../../DLLs")
         original_path = os.environ['PATH']
         os.environ['PATH'] = "%s;%s;%s" % (egg_dlls, wininst_dlls, original_path)
@@ -94,10 +94,15 @@ def _geos_c_version():
     func = _lgeos.GEOSversion
     func.argtypes = []
     func.restype = c_char_p
-    v = func().split('-')[2]
-    return tuple(int(n) for n in v.split('.'))
+    v = func()
+    c_ver = v.split('-')[2]
+    # Ditch any SVN revision numbering that may have crept in without (ftm)
+    # importing `re`.
+    c_ver = c_ver.split()[0]
+    return tuple(int(n) for n in c_ver.split('.')), v
 
-geos_capi_version = geos_c_version = _geos_c_version()
+geos_capi_version, geos_version_string = _geos_c_version()
+geos_c_version = geos_capi_version
 
 # If we have the new interface, then record a baseline so that we know what
 # additional functions are declared in ctypes_declarations.
@@ -112,7 +117,7 @@ prototype(_lgeos, geos_c_version)
 if geos_c_version >= (1,5,0):
     end_set = set(_lgeos.__dict__)
     new_func_names = end_set - start_set
-    
+
     for func_name in new_func_names:
         new_func_name = "%s_r" % func_name
         if hasattr(_lgeos, new_func_name):
@@ -127,7 +132,7 @@ if geos_c_version >= (1,5,0):
                 new_func.argtypes = [c_void_p] + old_func.argtypes
             if old_func.errcheck is not None:
                 new_func.errcheck = old_func.errcheck
-    
+
     # Handle special case.
     _lgeos.initGEOS_r.restype = c_void_p
     _lgeos.initGEOS_r.argtypes = [EXCEPTION_HANDLER_FUNCTYPE, EXCEPTION_HANDLER_FUNCTYPE]
@@ -192,9 +197,9 @@ class LGEOSBase(threading.local):
     def __init__(self, dll):
         self._lgeos = dll
         self.geos_handle = None
-        
 
-class LGEOS14(LGEOSBase):    
+
+class LGEOS14(LGEOSBase):
     """Proxy for the GEOS_C DLL/SO API version 1.4
     """
     geos_capi_version = (1, 4, 0)
@@ -256,12 +261,13 @@ class LGEOS14(LGEOSBase):
         self.methods['simplify'] = self.GEOSSimplify
         self.methods['topology_preserve_simplify'] = \
             self.GEOSTopologyPreserveSimplify
+        self.methods['cascaded_union'] = self.GEOSUnionCascaded
 
 
-class LGEOS15(LGEOSBase):    
+class LGEOS15(LGEOSBase):
     """Proxy for the reentrant GEOS_C DLL/SO API version 1.5
     """
-    geos_capi_version = (1, 5, 0)    
+    geos_capi_version = (1, 5, 0)
     def __init__(self, dll):
         super(LGEOS15, self).__init__(dll)
         self.geos_handle = self._lgeos.initGEOS_r(notice_h, error_h)
@@ -297,7 +303,7 @@ class LGEOS15(LGEOSBase):
             pred.func.errcheck = errcheck_predicate
 
         self.GEOSisValidReason.func.errcheck = errcheck_just_free
-        
+
         self.methods['area'] = self.GEOSArea
         self.methods['boundary'] = self.GEOSBoundary
         self.methods['buffer'] = self.GEOSBuffer
@@ -334,6 +340,8 @@ class LGEOS15(LGEOSBase):
         self.methods['simplify'] = self.GEOSSimplify
         self.methods['topology_preserve_simplify'] = \
             self.GEOSTopologyPreserveSimplify
+        self.methods['cascaded_union'] = self.GEOSUnionCascaded
+
 
 class LGEOS16(LGEOS15):
     """Proxy for the reentrant GEOS_C DLL/SO API version 1.6
@@ -342,8 +350,10 @@ class LGEOS16(LGEOS15):
     def __init__(self, dll):
         super(LGEOS16, self).__init__(dll)
 
+        self.methods['buffer_with_style'] = self.GEOSBufferWithStyle
 
-class LGEOS16LR(LGEOS16):    
+
+class LGEOS16LR(LGEOS16):
     """Proxy for the reentrant GEOS_C DLL/SO API version 1.6 with linear
     referencing
     """
@@ -359,7 +369,28 @@ class LGEOS16LR(LGEOS16):
             self.GEOSInterpolateNormalized
 
 
-if geos_c_version >= (1, 6, 0):
+class LGEOS17(LGEOS16LR):
+    """Proxy for the reentrant GEOS_C DLL/SO API version 1.7
+    """
+    geos_capi_version = (1, 7, 0)
+    def __init__(self, dll):
+        super(LGEOS17, self).__init__(dll)
+        
+        # GEOS 3.3.8 from homebrew has, but doesn't advertise 
+        # GEOSPolygonize_full. We patch it in explicitly here.
+        key = 'GEOSPolygonize_full'
+        func = getattr(self._lgeos, key + '_r')
+        attr = ftools.partial(func, self.geos_handle)
+        attr.__name__ = func.__name__
+        setattr(self, key, attr)
+
+        self.methods['unary_union'] = self.GEOSUnaryUnion
+        self.methods['cascaded_union'] = self.methods['unary_union']
+
+
+if geos_c_version >= (1, 7, 0):
+    L = LGEOS17
+elif geos_c_version >= (1, 6, 0):
     if hasattr(_lgeos, 'GEOSProject'):
         L = LGEOS16LR
     else:

shapely/impl.py

@@ -4,7 +4,7 @@ This is layer number 2 from the list below.
 
 1) geometric objects: the Python OO API.
 2) implementation map: an abstraction that permits different backends.
-3) backend: callable objects that take Shapely geometric objects as arguments 
+3) backend: callable objects that take Shapely geometric objects as arguments
    and, with GEOS as a backend, translate them to C data structures.
 4) GEOS library: algorithms implemented in C++.
 
@@ -22,7 +22,7 @@ from shapely.topology import BinaryRealProperty, BinaryTopologicalOp
 from shapely.topology import UnaryRealProperty, UnaryTopologicalOp
 
 def delegated(func):
-    """A delegated method raises AttributeError in the absence of backend 
+    """A delegated method raises AttributeError in the absence of backend
     support."""
     @wraps(func)
     def wrapper(*args, **kwargs):
@@ -42,6 +42,8 @@ class BaseImpl(object):
         self.map.update(values)
     def __getitem__(self, key):
         return self.map[key]
+    def __contains__(self, key):
+        return key in self.map
 
 class GEOSImpl(BaseImpl):
     def __repr__(self):
@@ -82,23 +84,24 @@ IMPL14 = {
     'touches': (BinaryPredicate, 'touches'),
     'within': (BinaryPredicate, 'within'),
     'equals_exact': (BinaryPredicate, 'equals_exact'),
-    
+
     # First pure Python implementation
     'is_ccw': (cga.is_ccw_impl, 'is_ccw'),
     }
 
 IMPL15 = {
     'simplify': (UnaryTopologicalOp, 'simplify'),
-    'topology_preserve_simplify': 
+    'topology_preserve_simplify':
         (UnaryTopologicalOp, 'topology_preserve_simplify'),
     'prepared_intersects': (BinaryPredicate, 'prepared_intersects'),
     'prepared_contains': (BinaryPredicate, 'prepared_contains'),
-    'prepared_contains_properly': 
+    'prepared_contains_properly':
         (BinaryPredicate, 'prepared_contains_properly'),
     'prepared_covers': (BinaryPredicate, 'prepared_covers'),
     }
 
 IMPL16 = {
+    'buffer_with_style': (UnaryTopologicalOp, 'buffer_with_style'),
     }
 
 IMPL16LR = {

shapely/ops.py

@@ -2,13 +2,14 @@
 """
 
 from ctypes import byref, c_void_p
+from itertools import izip
 
 from shapely.geos import lgeos
 from shapely.geometry.base import geom_factory, BaseGeometry
 from shapely.geometry import asShape, asLineString, asMultiLineString
 
-__all__= ['operator', 'polygonize', 'linemerge', 'cascaded_union']
-
+__all__= ['cascaded_union', 'linemerge', 'operator', 'polygonize', 
+          'polygonize_full', 'transform', 'unary_union']
 
 class CollectionOperator(object):
 
@@ -41,6 +42,41 @@ class CollectionOperator(object):
             g._owned = False
             yield g
 
+    def polygonize_full(self, lines):
+        """Creates polygons from a source of lines, returning the polygons
+        and leftover geometries.
+        
+        The source may be a MultiLineString, a sequence of LineString objects,
+        or a sequence of objects than can be adapted to LineStrings.
+        
+        Returns a tuple of objects: (polygons, dangles, cut edges, invalid ring
+        lines). Each are a geometry collection.
+        
+        Dangles are edges which have one or both ends which are not incident on
+        another edge endpoint. Cut edges are connected at both ends but do not
+        form part of polygon. Invalid ring lines form rings which are invalid
+        (bowties, etc).
+        """
+        source = getattr(lines, 'geoms', None) or lines
+        obs = [self.shapeup(l) for l in source]
+
+        L = len(obs)
+        subs = (c_void_p * L)()
+        for i, g in enumerate(obs):
+            subs[i] = g._geom
+        collection = lgeos.GEOSGeom_createCollection(5, subs, L)
+        dangles = c_void_p()
+        cuts = c_void_p()
+        invalids = c_void_p()
+        product = lgeos.GEOSPolygonize_full(
+            collection, byref(dangles), byref(cuts), byref(invalids))
+        return (
+            geom_factory(product),
+            geom_factory(dangles),
+            geom_factory(cuts),
+            geom_factory(invalids)
+            )
+
     def linemerge(self, lines): 
         """Merges all connected lines from a source
         
@@ -71,13 +107,28 @@ class CollectionOperator(object):
         for i, g in enumerate(geoms):
             subs[i] = g._geom
         collection = lgeos.GEOSGeom_createCollection(6, subs, L)
-        return geom_factory(lgeos.GEOSUnionCascaded(collection))
+        return geom_factory(lgeos.methods['cascaded_union'](collection))
 
+    def unary_union(self, geoms):
+        """Returns the union of a sequence of geometries
+
+        This method replaces :meth:`cascaded_union` as the
+        prefered method for dissolving many polygons.
+
+        """
+        L = len(geoms)
+        subs = (c_void_p * L)()
+        for i, g in enumerate(geoms):
+            subs[i] = g._geom
+        collection = lgeos.GEOSGeom_createCollection(6, subs, L)
+        return geom_factory(lgeos.methods['unary_union'](collection))
 
 operator = CollectionOperator()
 polygonize = operator.polygonize
+polygonize_full = operator.polygonize_full
 linemerge = operator.linemerge
 cascaded_union = operator.cascaded_union
+unary_union = operator.unary_union
 
 class ValidateOp(object):
     def __call__(self, this):
@@ -85,3 +136,74 @@ class ValidateOp(object):
 
 validate = ValidateOp()
 
+def transform(func, geom):
+    """Applies `func` to all coordinates of `geom` and returns a new 
+    geometry of the same type from the transformed coordinates.
+
+    `func` maps x, y, and optionally z to output xp, yp, zp. The input
+    parameters may iterable types like lists or arrays or single values.
+    The output shall be of the same type. Scalars in, scalars out. 
+    Lists in, lists out.
+
+    For example, here is an identity function applicable to both types
+    of input.
+    
+      def id_func(x, y, z=None):
+          return tuple(filter(None, [x, y, z]))
+      
+      g2 = transform(id_func, g1)
+
+    A partially applied transform function from pyproj satisfies the
+    requirements for `func`.
+
+      from functools import partial
+      import pyproj
+
+      project = partial(
+          pyproj.transform, 
+          pyproj.Proj(init='espg:4326'), 
+          pyproj.Proj(init='epsg:26913'))
+
+      g2 = transform(project, g1)
+    
+    Lambda expressions such as the one in
+
+      g2 = transform(lambda x, y, z=None: (x+1.0, y+1.0), g1)
+
+    also satisfy the requirements for `func`.
+    """
+
+    if geom.type in ('Point', 'LineString', 'Polygon'):
+        
+        # First we try to apply func to x, y, z sequences. When func is
+        # optimized for sequences, this is the fastest, though zipping
+        # the results up to go back into the geometry constructors adds
+        # extra cost.
+        try:
+            if geom.type in ('Point', 'LineString'):
+                return type(geom)(zip(*func(*izip(*geom.coords))))
+            elif geom.type == 'Polygon':
+                shell = type(geom.exterior)(
+                    zip(*func(*izip(*geom.exterior.coords))))
+                holes = list(type(ring)(zip(*func(*izip(*ring.coords)))) for 
+                    ring in geom.interiors)
+                return type(geom)(shell, holes)
+        
+        # A func that assumes x, y, z are single values will likely raise a
+        # TypeError, in which case we'll try again.
+        except TypeError:
+            if geom.type in ('Point', 'LineString'):
+                return type(geom)([func(*c) for c in geom.coords])
+            elif geom.type == 'Polygon':
+                shell = type(geom.exterior)(
+                    [func(*c) for c in geom.exterior.coords])
+                holes = list(type(ring)(
+                    [func(*c) for c in ring.coords]) for 
+                        ring in geom.interiors)
+                return type(geom)(shell, holes)
+    
+    elif geom.type.startswith('Multi') or geom.type == 'GeometryCollection':
+        return type(geom)([transform(func, part) for part in geom.geoms])
+    else:
+        raise ValueError('Type %r not recognized' % geom.type)
+