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

EGG-INFO/PKG-INFO

@@ -1,34 +1,34 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.2.10
+Version: 1.2.13
 Summary: Geometric objects, predicates, and operations
-Home-page: http://trac.gispython.org/lab/wiki/Shapely
+Home-page: https://github.com/sgillies/shapely
 Author: Sean Gillies
 Author-email: sean.gillies@gmail.com
 License: BSD
-Description: ======
-        README
-        ======
+Description: =======
+        Shapely
+        =======
+        
+        PostGIS-ish operations outside a database context for Pythoneers and Pythonistas
         
         .. image:: http://farm3.static.flickr.com/2738/4511827859_b5822043b7_o_d.png
            :width: 800
            :height: 400
         
         Shapely is a BSD-licensed Python package for manipulation and analysis of
-        planar geometric objects. It is not concerned with data formats or coordinate
-        systems.  It is based on the widely deployed GEOS_ (the engine of PostGIS_) and
-        JTS_ (from which GEOS is ported) libraries. This C dependency is traded for the
-        ability to execute with blazing speed.
-        
-        In a nutshell: Shapely lets you do PostGIS-ish stuff outside the context of a
-        database using idiomatic Python. For more details, see:
+        planar geometric objects. It is based on the widely deployed GEOS_ (the engine
+        of PostGIS_) and JTS_ (from which GEOS is ported) libraries. This C dependency
+        is traded for the ability to execute with blazing speed. Shapely is not
+        concerned with data formats or coordinate systems, but can be readily
+        integrated with packages that are. For more details, see:
         
         * Shapely wiki_
         * Shapely manual_
         * Shapely `example apps`_
         
         Dependencies
-        ------------
+        ============
         
         Shapely 1.2 depends on:
         
@@ -36,7 +36,7 @@ Description: ======
         * libgeos_c >=3.1 (3.0 and below have not been tested, YMMV)
         
         Installation
-        ------------
+        ============
         
         Windows users should use the executable installer, which contains the required
         GEOS DLL. Other users should acquire libgeos_c by any means, make sure that it
@@ -49,7 +49,7 @@ Description: ======
           $ python setup.py install
         
         Usage
-        -----
+        =====
         
         Here is the canonical example of building an approximately circular patch by
         buffering a point::
@@ -65,7 +65,7 @@ Description: ======
         intersect.py `example apps`_.
         
         Integration 
-        -----------
+        ===========
         
         Shapely does not read or write data files, but it can serialize and deserialize
         using several well known formats and protocols. The shapely.wkb and shapely.wkt
@@ -88,8 +88,8 @@ Description: ======
                  [  1.00000000e+01,   0.00000000e+00]])
         
         That yields a numpy array of [x, y] arrays. This is not always exactly what one
-        wants for plotting shapes with Matplotlib, so Shapely 1.2 adds a `xy` property
-        for getting separate arrays of coordinate x and y values.::
+        wants for plotting shapes with Matplotlib (for example), so Shapely 1.2 adds
+        a `xy` property for obtaining separate arrays of coordinate x and y values.::
         
           >>> x, y = patch.exterior.xy
           >>> ax = asarray(x)
@@ -105,7 +105,7 @@ Description: ======
           'LINESTRING (10.0000000000000000 0.0000000000000000, ...)'
         
         Testing
-        -------
+        =======
         
         Shapely uses a Zope-stye suite of unittests and doctests, excercised via
         setup.py.::
@@ -116,16 +116,12 @@ Description: ======
         supported well by nose.
         
         Support
-        -------
-        
-        For current information about this project, see the wiki_.
-        
-        If you have questions, please consider joining our community list:
+        =======
         
-        http://trac.gispython.org/projects/PCL/wiki/CommunityList
+        Bugs may be reported and questions asked via https://github.com/sgillies/shapely.
         
         Credits
-        -------
+        =======
         
         Shapely is written by:
         
@@ -136,8 +132,8 @@ Description: ======
         Patches contributed by:
         
         * Howard Butler
-        * Fr |eaigue| d |eaigue| ric Junod
-        * Eric Lemoine
+        * Fr |eacute| d |eacute| ric Junod
+        * |Eacute| ric Lemoine
         * Jonathan Tartley
         * Kristian Thy
         * Oliver Tonnhofer
@@ -158,7 +154,9 @@ Description: ======
         .. _example apps: http://trac.gispython.org/lab/wiki/Examples
         .. _wiki: http://trac.gispython.org/lab/wiki/Shapely
         .. _manual: http://gispython.org/shapely/docs/1.2
-        .. |eaigue| unicode:: U+00E9
+        .. |eacute| unicode:: U+00E9
+           :trim:
+        .. |Eacute| unicode:: U+00C9
            :trim:
         .. _Pleiades: http://pleiades.stoa.org
         
@@ -166,6 +164,27 @@ Description: ======
         CHANGES
         =======
         
+        1.2.13 (2011-09-16)
+        -------------------
+        - Fixed errors in speedups on 32bit systems when GEOS references memory above 2GB.
+        - Add shapely.__version__ attribute.
+        - Update the manual.
+        
+        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/__init__.py

@@ -1 +1,2 @@
-# package
+__version__ = "1.2.13"
+

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