shapely 1.2.10__py2.7-win32.egg → 1.2.12__py2.7-win32.egg

EGG-INFO/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.2.10
+Version: 1.2.12
 Summary: Geometric objects, predicates, and operations
 Home-page: http://trac.gispython.org/lab/wiki/Shapely
 Author: Sean Gillies
@@ -166,6 +166,21 @@ Description: ======
         CHANGES
         =======
         
+        1.2.12 (2011-08-15)
+        -------------------
+        - Build Windows distributions with VC7 or VC9 as appropriate.
+        - More verbose report on failure to speed up.
+        - Fix for prepared geometries broken in 1.2.11.
+        - DO NOT INSTALL 1.2.11
+        
+        1.2.11 (2011-08-04)
+        -------------------
+        - Ignore AttributeError during exit.
+        - PyPy 1.5 support.
+        - Prevent operation on prepared geometry crasher (#12).
+        - Optional Cython speedups for Windows.
+        - Linux 3 platform support.
+        
         1.2.10 (2011-05-09)
         -------------------
         - Add optional Cython speedups.

EGG-INFO/native_libs.txt

@@ -0,0 +1 @@
+shapely/speedups/_speedups.pyd

shapely/ctypes_declarations.py

@@ -6,12 +6,17 @@ import ctypes
 class allocated_c_char_p(ctypes.c_char_p):
     pass
 
+EXCEPTION_HANDLER_FUNCTYPE = ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_char_p)
+
 def prototype(lgeos, geosVersion):
 
+    lgeos.initGEOS.argtypes = [EXCEPTION_HANDLER_FUNCTYPE, EXCEPTION_HANDLER_FUNCTYPE]
     lgeos.initGEOS.restype = None
 
+    lgeos.finishGEOS.argtypes = []
     lgeos.finishGEOS.restype = None
 
+    lgeos.GEOSversion.argtypes = []
     lgeos.GEOSversion.restype = ctypes.c_char_p
 
     lgeos.GEOSGeomFromWKT.restype = ctypes.c_void_p

shapely/examples/__init__.py

@@ -0,0 +1 @@
+# Examples module

shapely/examples/dissolve.py

@@ -0,0 +1,53 @@
+# dissolve.py
+#
+# Demonstrate how Shapely can be used to build up a collection of patches by 
+# dissolving circular regions and how Shapely supports plotting of the results.
+
+from functools import partial
+import random
+
+import pylab
+
+from shapely.geometry import Point
+from shapely.ops import cascaded_union
+
+# Use a partial function to make 100 points uniformly distributed in a 40x40 
+# box centered on 0,0.
+r = partial(random.uniform, -20.0, 20.0)
+points = [Point(r(), r()) for i in range(100)]
+
+# Buffer the points, producing 100 polygon spots
+spots = [p.buffer(2.5) for p in points]
+
+# Perform a cascaded union of the polygon spots, dissolving them into a 
+# collection of polygon patches
+patches = cascaded_union(spots)
+
+if __name__ == "__main__":
+    # Illustrate the results using matplotlib's pylab interface
+    pylab.figure(num=None, figsize=(4, 4), dpi=180)
+    
+    for patch in patches.geoms:
+        assert patch.geom_type in ['Polygon']
+        assert patch.is_valid
+    
+        # Fill and outline each patch
+        x, y = patch.exterior.xy
+        pylab.fill(x, y, color='#cccccc', aa=True) 
+        pylab.plot(x, y, color='#666666', aa=True, lw=1.0)
+    
+        # Do the same for the holes of the patch
+        for hole in patch.interiors:
+            x, y = hole.xy
+            pylab.fill(x, y, color='#ffffff', aa=True) 
+            pylab.plot(x, y, color='#999999', aa=True, lw=1.0)
+    
+    # Plot the original points
+    pylab.plot([p.x for p in points], [p.y for p in points], 'b,', alpha=0.75)
+    
+    # Write the number of patches and the total patch area to the figure
+    pylab.text(-25, 25, 
+        "Patches: %d, total area: %.2f" % (len(patches.geoms), patches.area))
+    
+    pylab.savefig('dissolve.png')
+    

shapely/examples/geoms.py

@@ -0,0 +1,51 @@
+from numpy import asarray
+import pylab
+from shapely.geometry import Point, LineString, Polygon
+
+polygon = Polygon(((-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0)))
+
+point_r = Point(-1.5, 1.2)
+point_g = Point(-1.0, 1.0)
+point_b = Point(-0.5, 0.5)
+
+line_r = LineString(((-0.5, 0.5), (0.5, 0.5)))
+line_g = LineString(((1.0, -1.0), (1.8, 0.5)))
+line_b = LineString(((-1.8, -1.2), (1.8, 0.5)))
+
+def plot_point(g, o, l):
+    pylab.plot([g.x], [g.y], o, label=l)
+
+def plot_line(g, o):
+    a = asarray(g)
+    pylab.plot(a[:,0], a[:,1], o)
+
+def fill_polygon(g, o):
+    a = asarray(g.exterior)
+    pylab.fill(a[:,0], a[:,1], o, alpha=0.5)
+
+def fill_multipolygon(g, o):
+    for g in g.geoms:
+        fill_polygon(g, o)
+
+if __name__ == "__main__":
+    from numpy import asarray
+    import pylab
+    
+    fig = pylab.figure(1, figsize=(4, 3), dpi=150)
+    #pylab.axis([-2.0, 2.0, -1.5, 1.5])
+    pylab.axis('tight')
+
+    a = asarray(polygon.exterior)
+    pylab.fill(a[:,0], a[:,1], 'c')
+
+    plot_point(point_r, 'ro', 'b')
+    plot_point(point_g, 'go', 'c')
+    plot_point(point_b, 'bo', 'd')
+
+    plot_line(line_r, 'r')
+    plot_line(line_g, 'g')
+    plot_line(line_b, 'b')
+
+    pylab.show()
+
+

shapely/examples/intersect.py

@@ -0,0 +1,81 @@
+# intersect.py
+#
+# Demonstrate how Shapely can be used to analyze and plot the intersection of
+# a trajectory and regions in space.
+
+from functools import partial
+import random
+
+import pylab
+
+from shapely.geometry import LineString, Point
+from shapely.ops import cascaded_union
+
+# Build patches as in dissolved.py
+r = partial(random.uniform, -20.0, 20.0)
+points = [Point(r(), r()) for i in range(100)]
+spots = [p.buffer(2.5) for p in points]
+patches = cascaded_union(spots)
+
+# Represent the following geolocation parameters
+#
+# initial position: -25, -25
+# heading: 45.0
+# speed: 50*sqrt(2)
+#
+# as a line
+vector = LineString(((-25.0, -25.0), (25.0, 25.0)))
+
+# Find intercepted and missed patches. List the former so we can count them
+# later
+intercepts = [patch for patch in patches.geoms if vector.intersects(patch)]
+misses = (patch for patch in patches.geoms if not vector.intersects(patch))
+
+# Plot the intersection
+intersection = vector.intersection(patches)
+assert intersection.geom_type in ['MultiLineString']
+
+if __name__ == "__main__":
+    # Illustrate the results using matplotlib's pylab interface
+    pylab.figure(num=None, figsize=(4, 4), dpi=180)
+    
+    # Plot the misses
+    for spot in misses:
+        x, y = spot.exterior.xy
+        pylab.fill(x, y, color='#cccccc', aa=True) 
+        pylab.plot(x, y, color='#999999', aa=True, lw=1.0)
+    
+        # Do the same for the holes of the patch
+        for hole in spot.interiors:
+            x, y = hole.xy
+            pylab.fill(x, y, color='#ffffff', aa=True) 
+            pylab.plot(x, y, color='#999999', aa=True, lw=1.0)
+    
+    # Plot the intercepts
+    for spot in intercepts:
+        x, y = spot.exterior.xy
+        pylab.fill(x, y, color='red', alpha=0.25, aa=True) 
+        pylab.plot(x, y, color='red', alpha=0.5, aa=True, lw=1.0)
+    
+        # Do the same for the holes of the patch
+        for hole in spot.interiors:
+            x, y = hole.xy
+            pylab.fill(x, y, color='#ffffff', aa=True) 
+            pylab.plot(x, y, color='red', alpha=0.5, aa=True, lw=1.0)
+    
+    # Draw the projected trajectory
+    pylab.arrow(-25, -25, 50, 50, color='#999999', aa=True,
+        head_width=1.0, head_length=1.0)
+    
+    for segment in intersection.geoms:
+        x, y = segment.xy
+        pylab.plot(x, y, color='red', aa=True, lw=1.5)
+    
+    # Write the number of patches and the total patch area to the figure
+    pylab.text(-28, 25, 
+        "Patches: %d/%d (%d), total length: %.1f" \
+         % (len(intercepts), len(patches.geoms), 
+            len(intersection.geoms), intersection.length))
+    
+    pylab.savefig('intersect.png')
+    

shapely/examples/world.py

@@ -0,0 +1,21 @@
+import ogr
+import pylab
+from numpy import asarray
+
+from shapely.wkb import loads
+
+source = ogr.Open("/var/gis/data/world/world_borders.shp")
+borders = source.GetLayerByName("world_borders")
+
+fig = pylab.figure(1, figsize=(4,2), dpi=300)
+
+while 1:
+    feature = borders.GetNextFeature()
+    if not feature:
+        break
+    
+    geom = loads(feature.GetGeometryRef().ExportToWkb())
+    a = asarray(geom)
+    pylab.plot(a[:,0], a[:,1])
+
+pylab.show()

shapely/geometry/base.py

@@ -104,7 +104,10 @@ class BaseGeometry(object):
         # TODO: defer cleanup to the implementation. We shouldn't be
         # explicitly calling a lgeos method here.
         if not (self._owned or self._is_empty):
-            self._lgeos.GEOSGeom_destroy(self.__geom__)
+            try:
+                self._lgeos.GEOSGeom_destroy(self.__geom__)
+            except AttributeError:
+                pass # _lgeos might be empty on shutdown
         self.__geom__ = EMPTY
 
     def __del__(self):

shapely/geometry/linestring.py

@@ -167,9 +167,10 @@ def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
         assert n == 2 or n == 3
 
         # Make pointer to the coordinate array
-        try:
+        if isinstance(array['data'], tuple):
+            # numpy tuple (addr, read-only)
             cp = cast(array['data'][0], POINTER(c_double))
-        except ArgumentError:
+        else:
             cp = array['data']
 
         # Create a coordinate sequence
@@ -226,21 +227,15 @@ def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
         # add to coordinate sequence
         for i in xrange(m):
             coords = ob[i]
-            dx = c_double(coords[0])
-            dy = c_double(coords[1])
-            dz = None
+            # 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])
             if n == 3:
                 try:
-                    dz = c_double(coords[2])
+                    lgeos.GEOSCoordSeq_setZ(cs, i, coords[2])
                 except IndexError:
                     raise ValueError("Inconsistent coordinate dimensionality")
-        
-            # 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)
-            if n == 3:
-                lgeos.GEOSCoordSeq_setZ(cs, i, dz)
     
     if update_geom is not None:
         return None

shapely/geometry/multilinestring.py

@@ -93,9 +93,6 @@ def geos_multilinestring_from_py(ob):
         L = array['shape'][0]
         assert L >= 1
 
-        # Make pointer to the coordinate array
-        cp = cast(array['data'][0], POINTER(c_double))
-
         # Array of pointers to sub-geometries
         subs = (c_void_p * L)()
 

shapely/geometry/multipoint.py

@@ -138,9 +138,10 @@ def geos_multipoint_from_py(ob):
         assert n == 2 or n == 3
 
         # Make pointer to the coordinate array
-        try:
+        if isinstance(array['data'], tuple):
+            # numpy tuple (addr, read-only)
             cp = cast(array['data'][0], POINTER(c_double))
-        except ArgumentError:
+        else:
             cp = array['data']
 
         # Array of pointers to sub-geometries

shapely/geometry/polygon.py

@@ -312,9 +312,10 @@ def geos_linearring_from_py(ob, update_geom=None, update_ndim=0):
         assert n == 2 or n == 3
 
         # Make pointer to the coordinate array
-        try:
+        if isinstance(array['data'], tuple):
+            # numpy tuple (addr, read-only)
             cp = cast(array['data'][0], POINTER(c_double))
-        except ArgumentError:
+        else:
             cp = array['data']
 
         # Add closing coordinates to sequence?
@@ -335,33 +336,21 @@ def geos_linearring_from_py(ob, update_geom=None, update_ndim=0):
 
         # add to coordinate sequence
         for i in xrange(m):
-            dx = c_double(cp[n*i])
-            dy = c_double(cp[n*i+1])
-            dz = None
-            if n == 3:
-                dz = c_double(cp[n*i+2])
-        
             # 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)
+            lgeos.GEOSCoordSeq_setX(cs, i, cp[n*i])
+            lgeos.GEOSCoordSeq_setY(cs, i, cp[n*i+1])
             if n == 3:
-                lgeos.GEOSCoordSeq_setZ(cs, i, dz)
+                lgeos.GEOSCoordSeq_setZ(cs, i, cp[n*i+2])
 
         # Add closing coordinates to sequence?
-        if M > m:
-            dx = c_double(cp[0])
-            dy = c_double(cp[1])
-            dz = None
-            if n == 3:
-                dz = c_double(cp[2])
-        
+        if M > m:        
             # Because of a bug in the GEOS C API, 
             # always set X before Y
-            lgeos.GEOSCoordSeq_setX(cs, M-1, dx)
-            lgeos.GEOSCoordSeq_setY(cs, M-1, dy)
+            lgeos.GEOSCoordSeq_setX(cs, M-1, cp[0])
+            lgeos.GEOSCoordSeq_setY(cs, M-1, cp[1])
             if n == 3:
-                lgeos.GEOSCoordSeq_setZ(cs, M-1, dz)
+                lgeos.GEOSCoordSeq_setZ(cs, M-1, cp[2])
             
     except AttributeError:
         # Fall back on list
@@ -391,34 +380,25 @@ def geos_linearring_from_py(ob, update_geom=None, update_ndim=0):
         # add to coordinate sequence
         for i in xrange(m):
             coords = ob[i]
-            dx = c_double(coords[0])
-            dy = c_double(coords[1])
-            dz = None
-            if n == 3:
-                dz = c_double(coords[2])
-        
             # 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)
+            lgeos.GEOSCoordSeq_setX(cs, i, coords[0])
+            lgeos.GEOSCoordSeq_setY(cs, i, coords[1])
             if n == 3:
-                lgeos.GEOSCoordSeq_setZ(cs, i, dz)
+                try:
+                    lgeos.GEOSCoordSeq_setZ(cs, i, coords[2])
+                except IndexError:
+                    raise ValueError("Inconsistent coordinate dimensionality")
 
         # Add closing coordinates to sequence?
         if M > m:
             coords = ob[0]
-            dx = c_double(coords[0])
-            dy = c_double(coords[1])
-            dz = None
-            if n == 3:
-                dz = c_double(coords[2])
-        
             # Because of a bug in the GEOS C API, 
             # always set X before Y
-            lgeos.GEOSCoordSeq_setX(cs, M-1, dx)
-            lgeos.GEOSCoordSeq_setY(cs, M-1, dy)
+            lgeos.GEOSCoordSeq_setX(cs, M-1, coords[0])
+            lgeos.GEOSCoordSeq_setY(cs, M-1, coords[1])
             if n == 3:
-                lgeos.GEOSCoordSeq_setZ(cs, M-1, dz)
+                lgeos.GEOSCoordSeq_setZ(cs, M-1, coords[2])
 
     if update_geom is not None:
         return None

shapely/geos.py

@@ -12,7 +12,7 @@ from ctypes import cdll, CDLL, CFUNCTYPE, c_char_p, c_void_p, string_at
 from ctypes.util import find_library
 
 import ftools
-from ctypes_declarations import prototype
+from ctypes_declarations import prototype, EXCEPTION_HANDLER_FUNCTYPE
 
 
 
@@ -43,7 +43,7 @@ def load_dll(libname, fallbacks=None):
             "Could not find library %s or load any of its variants %s" % (
                 libname, fallbacks or []))
        
-if sys.platform == 'linux2':
+if sys.platform.startswith('linux'):
     _lgeos = load_dll('geos_c', fallbacks=['libgeos_c.so.1', 'libgeos_c.so'])
     free = load_dll('c').free
     free.argtypes = [c_void_p]
@@ -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)
@@ -92,6 +92,7 @@ else: # other *nix systems
 
 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('.'))
@@ -129,7 +130,7 @@ if geos_c_version >= (1,5,0):
     
     # Handle special case.
     _lgeos.initGEOS_r.restype = c_void_p
-    _lgeos.initGEOS_r.argtypes = [c_void_p, c_void_p]
+    _lgeos.initGEOS_r.argtypes = [EXCEPTION_HANDLER_FUNCTYPE, EXCEPTION_HANDLER_FUNCTYPE]
     _lgeos.finishGEOS_r.argtypes = [c_void_p]
 
 # Exceptions
@@ -148,11 +149,11 @@ class PredicateError(Exception):
 
 def error_handler(fmt, list):
     LOG.error("%s", list)
-error_h = CFUNCTYPE(None, c_char_p, c_char_p)(error_handler)
+error_h = EXCEPTION_HANDLER_FUNCTYPE(error_handler)
 
 def notice_handler(fmt, list):
     LOG.warning("%s", list)
-notice_h = CFUNCTYPE(None, c_char_p, c_char_p)(notice_handler)
+notice_h = EXCEPTION_HANDLER_FUNCTYPE(notice_handler)
 
 def cleanup():
     if _lgeos is not None :
@@ -166,7 +167,7 @@ def errcheck_wkb(result, func, argtuple):
     if not result:
         return None
     size_ref = argtuple[-1]
-    size = size_ref._obj
+    size = size_ref.contents
     retval = ctypes.string_at(result, size.value)[:]
     lgeos.GEOSFree(result)
     return retval

shapely/predicates.py

@@ -7,13 +7,13 @@ from shapely.topology import Delegating
 class BinaryPredicate(Delegating):
     def __call__(self, this, other, *args):
         self._validate(this)
-        self._validate(other)
+        self._validate(other, stop_prepared=True)
         return self.fn(this._geom, other._geom, *args)
 
 class RelateOp(Delegating):
     def __call__(self, this, other):
         self._validate(this)
-        self._validate(other)
+        self._validate(other, stop_prepared=True)
         return self.fn(this._geom, other._geom)
 
 class UnaryPredicate(Delegating):

shapely/prepared.py

@@ -27,7 +27,10 @@ class PreparedGeometry(object):
     
     def __del__(self):
         if self.__geom__ is not None:
-            lgeos.GEOSPreparedGeom_destroy(self.__geom__)
+            try:
+                lgeos.GEOSPreparedGeom_destroy(self.__geom__)
+            except AttributeError:
+                pass # lgeos might be empty on shutdown
         self.__geom__ = None
         self.context = None
     

shapely/speedups/__init__.py

@@ -0,0 +1,42 @@
+import warnings
+
+from shapely.geometry import linestring, polygon
+from shapely import coords
+
+try:
+    from shapely.speedups import _speedups
+    available = True
+    import_error_msg = None
+except ImportError:
+    import sys
+    available = False
+    import_error_msg = tuple(sys.exc_info()[1])
+
+__all__ = ['available', 'enable', 'disable']
+_orig = {}
+
+def enable():
+    if not available:
+        warnings.warn("shapely.speedups not available", RuntimeWarning)
+        return
+    
+    if _orig:
+        return
+    
+    _orig['CoordinateSequence.ctypes'] = coords.CoordinateSequence.ctypes
+    coords.CoordinateSequence.ctypes = property(_speedups.coordseq_ctypes)
+    
+    _orig['geos_linestring_from_py'] = linestring.geos_linestring_from_py
+    linestring.geos_linestring_from_py = _speedups.geos_linestring_from_py
+
+    _orig['geos_linearring_from_py']  = polygon.geos_linearring_from_py
+    polygon.geos_linearring_from_py = _speedups.geos_linearring_from_py
+
+def disable():
+    if not _orig:
+        return
+
+    coords.CoordinateSequence.ctypes = _orig['CoordinateSequence.ctypes']
+    linestring.geos_linestring_from_py = _orig['geos_linestring_from_py']
+    polygon.geos_linearring_from_py = _orig['geos_linearring_from_py']
+    _orig.clear()

shapely/speedups/_speedups.py

@@ -0,0 +1,7 @@
+def __bootstrap__():
+   global __bootstrap__, __loader__, __file__
+   import sys, pkg_resources, imp
+   __file__ = pkg_resources.resource_filename(__name__,'_speedups.pyd')
+   __loader__ = None; del __bootstrap__, __loader__
+   imp.load_dynamic(__name__,__file__)
+__bootstrap__()

shapely/tests/__init__.py

@@ -0,0 +1,28 @@
+from unittest import TestSuite
+
+import test_doctests, test_prepared, test_equality, test_geomseq, test_xy
+import test_collection, test_emptiness, test_singularity, test_validation
+import test_mapping, test_delegated, test_dlls, test_linear_referencing
+import test_products_z, test_box, test_speedups, test_cga
+
+def test_suite():
+    suite = TestSuite()
+    suite.addTest(test_doctests.test_suite())
+    suite.addTest(test_prepared.test_suite())
+    suite.addTest(test_emptiness.test_suite())
+    suite.addTest(test_equality.test_suite())
+    suite.addTest(test_geomseq.test_suite())
+    suite.addTest(test_xy.test_suite())
+    suite.addTest(test_collection.test_suite())
+    suite.addTest(test_singularity.test_suite())
+    suite.addTest(test_validation.test_suite())
+    suite.addTest(test_mapping.test_suite())
+    suite.addTest(test_delegated.test_suite())
+    suite.addTest(test_dlls.test_suite())
+    suite.addTest(test_linear_referencing.test_suite())
+    suite.addTest(test_products_z.test_suite())
+    suite.addTest(test_box.test_suite())
+    suite.addTest(test_speedups.test_suite())
+    suite.addTest(test_cga.test_suite())
+    return suite
+