shapely 1.2b4__tar.gz → 1.2b6__tar.gz

{Shapely-1.2b4 → Shapely-1.2b6}/CHANGES.txt

@@ -1,5 +1,21 @@
 All tickets are children of http://trac.gispython.org/lab/ticket.
 
+1.2b6 (2010-04-13)
+------------------
+- Broken GeometryCollection fixed.
+
+1.2b5 (2010-04-09)
+------------------
+- Objects can be constructed from others of the same type, thereby making
+  copies. Collections can be constructed from sequences of objects, also making
+  copies.
+- Collections are now iterators over their component objects.
+- New code for manual figures, using the descartes package.
+
+1.2b4 (2010-03-19)
+------------------
+- Adds support for the "sunos5" platform.
+
 1.2b3 (2010-02-28)
 ------------------
 - Only provide simplification implementations for GEOS C API >= 1.5.

{Shapely-1.2b4 → Shapely-1.2b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.2b4
+Version: 1.2b6
 Summary: Planar geometries, predicates, and operations
 Home-page: http://trac.gispython.org/lab/wiki/Shapely
 Author: Sean Gillies
@@ -10,9 +10,9 @@ Description:
         Shapely
         =======
         
-        .. image:: http://gispython.org/images/shapely-med.png
-        :width: 640
-        :height: 320
+        .. 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 geometries. It is not concerned with data formats or coordinate

{Shapely-1.2b4 → Shapely-1.2b6}/README.txt

@@ -2,9 +2,9 @@
 Shapely
 =======
 
-.. image:: http://gispython.org/images/shapely-med.png
-   :width: 640
-   :height: 320
+.. 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 geometries. It is not concerned with data formats or coordinate

{Shapely-1.2b4 → Shapely-1.2b6}/Shapely.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.2b4
+Version: 1.2b6
 Summary: Planar geometries, predicates, and operations
 Home-page: http://trac.gispython.org/lab/wiki/Shapely
 Author: Sean Gillies
@@ -10,9 +10,9 @@ Description:
         Shapely
         =======
         
-        .. image:: http://gispython.org/images/shapely-med.png
-        :width: 640
-        :height: 320
+        .. 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 geometries. It is not concerned with data formats or coordinate

Shapely-1.2b6/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-1.2b6/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-1.2b4 → Shapely-1.2b6}/setup.py

@@ -16,7 +16,7 @@ readme_text = file('README.txt', 'rb').read()
 setup_args = dict(
     metadata_version    = '1.2',
     name                = 'Shapely',
-    version             = '1.2b4',
+    version             = '1.2b6',
     requires_python     = '>=2.5,<3',
     requires_external   = 'libgeos_c (>=3.1)', 
     description         = 'Planar geometries, predicates, and operations',

{Shapely-1.2b4 → Shapely-1.2b6}/shapely/geometry/base.py

@@ -48,8 +48,8 @@ def exceptNull(func):
     """Decorator which helps avoid GEOS operations on null pointers."""
     @wraps(func)
     def wrapper(*args, **kwargs):
-        if not args[0]._geom:
-            raise ValueError("Null geometry supports no operations")
+        if not args[0]._geom or args[0].is_empty:
+            raise ValueError("Null/empty geometry supports no operations")
         return func(*args, **kwargs)
     return wrapper
 
@@ -84,12 +84,12 @@ class BaseGeometry(object):
     _ndim = None
     _crs = None
     _owned = False
-
+    
     # Backend config
     impl = DefaultImplementation
 
     def __init__(self):
-        self.__geom__ = None
+        self.__geom__ = wkb.deserialize('010700000000000000'.decode('hex'))
 
     def __del__(self):
         if self.__geom__ is not None and not self._owned:
@@ -227,8 +227,11 @@ class BaseGeometry(object):
     @property
     def bounds(self):
         """Returns minimum bounding region (minx, miny, maxx, maxy)"""
-        return self.impl['bounds'](self)
-
+        if self.is_empty:
+            return ()
+        else:
+            return self.impl['bounds'](self)
+            
     @property
     def centroid(self):
         """Returns the geometric center of the polygon"""
@@ -451,6 +454,24 @@ class BaseMultipartGeometry(BaseGeometry):
     def geoms(self):
         return GeometrySequence(self, self.shape_factory)
 
+    def __iter__(self):
+        if not self.is_empty:
+            return iter(self.geoms)
+        else:
+            return iter([])
+
+    def __len__(self):
+        if not self.is_empty:
+            return len(self.geoms)
+        else:
+            return 0
+
+    def __getitem__(self, index):
+        if not self.is_empty:
+            return self.geoms[index]
+        else:
+            return ()[index]
+
 
 class GeometrySequence(object):
     """

{Shapely-1.2b4 → Shapely-1.2b6}/shapely/geometry/collection.py

@@ -16,7 +16,7 @@ class GeometryCollection(BaseMultipartGeometry):
     """
 
     def __init__(self):
-        BaseMultiPartGeometry.__init__(self)
+        BaseMultipartGeometry.__init__(self)
 
     @property
     def __geo_interface__(self):

{Shapely-1.2b4 → Shapely-1.2b6}/shapely/geometry/linestring.py

@@ -11,107 +11,6 @@ from shapely.geometry.proxy import CachingGeometryProxy
 __all__ = ['LineString', 'asLineString']
 
 
-def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
-    try:
-        # From array protocol
-        array = ob.__array_interface__
-        assert len(array['shape']) == 2
-        m = array['shape'][0]
-        if m < 2:
-            raise ValueError(
-                "LineStrings must have at least 2 coordinate tuples")
-        try:
-            n = array['shape'][1]
-        except IndexError:
-            raise ValueError(
-                "Input %s is the wrong shape for a LineString" % str(ob))
-        assert n == 2 or n == 3
-
-        # Make pointer to the coordinate array
-        try:
-            cp = cast(array['data'][0], POINTER(c_double))
-        except ArgumentError:
-            cp = array['data']
-
-        # Create a coordinate sequence
-        if update_geom is not None:
-            cs = lgeos.GEOSGeom_getCoordSeq(update_geom)
-            if n != update_ndim:
-                raise ValueError(
-                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
-                % update_ndim)
-        else:
-            cs = lgeos.GEOSCoordSeq_create(m, n)
-
-        # 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:
-                try:
-                    dz = c_double(cp[n*i+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)
-
-    except AttributeError:
-        # Fall back on list
-        m = len(ob)
-        if m < 2:
-            raise ValueError(
-                "LineStrings must have at least 2 coordinate tuples")
-        try:
-            n = len(ob[0])
-        except TypeError:
-            raise ValueError(
-                "Input %s is the wrong shape for a LineString" % str(ob))
-        assert n == 2 or n == 3
-
-        # Create a coordinate sequence
-        if update_geom is not None:
-            cs = lgeos.GEOSGeom_getCoordSeq(update_geom)
-            if n != update_ndim:
-                raise ValueError(
-                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
-                % update_ndim)
-        else:
-            cs = lgeos.GEOSCoordSeq_create(m, n)
-        
-        # 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:
-                try:
-                    dz = c_double(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
-    else:
-        return lgeos.GEOSGeom_createLineString(cs), n
-
-def update_linestring_from_py(geom, ob):
-    geos_linestring_from_py(ob, geom._geom, geom._ndim)
-
-
 class LineString(BaseGeometry):
     """
     A one-dimensional figure comprising one or more line segments
@@ -121,29 +20,21 @@ class LineString(BaseGeometry):
     """
 
     def __init__(self, coordinates=None):
-        """Initialize a linestring instance
-
+        """
         Parameters
         ----------
-        
         coordinates : sequence
-            A sequence of (x, y [,z]) numeric coordinate pairs or triples
+            A sequence of (x, y [,z]) numeric coordinate pairs or triples or
+            an object that provides the numpy array interface, including another
+            instance of LineString.
 
         Example
         -------
-
         Create a line with two segments
 
           >>> a = LineString([[0, 0], [1, 0], [1, 1]])
           >>> a.length
           2.0
-
-        Copy it by exploiting API symmetry
-
-          >>> b = LineString(a.coords)
-          >>> b.equals(a)
-          True
-
         """
         BaseGeometry.__init__(self)
         self._init_geom(coordinates)
@@ -177,6 +68,9 @@ class LineString(BaseGeometry):
     # Coordinate access
 
     def _set_coords(self, coordinates):
+        if self.is_empty:
+            lgeos.GEOSGeom_destroy(self.__geom__)
+            self.__geom__ = None
         if self._geom is None:
             self._init_geom(coordinates)
         update_linestring_from_py(self, coordinates)
@@ -194,17 +88,12 @@ class LineString(BaseGeometry):
           [0.0, 1.0]
           >>> list(y)
           [0.0, 1.0]
-        
         """
         return self.coords.xy
         
 
 class LineStringAdapter(CachingGeometryProxy, LineString):
 
-    """Adapts Python coordinate pairs or a numpy array to the line string
-    interface
-    """
-    
     context = None
     _owned = False
 
@@ -242,15 +131,114 @@ class LineStringAdapter(CachingGeometryProxy, LineString):
 
 
 def asLineString(context):
-    """Factory for PointAdapter instances."""
+    """Adapt an object the LineString interface"""
     return LineStringAdapter(context)
 
+
+def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
+    try:
+        # From array protocol
+        array = ob.__array_interface__
+        assert len(array['shape']) == 2
+        m = array['shape'][0]
+        if m < 2:
+            raise ValueError(
+                "LineStrings must have at least 2 coordinate tuples")
+        try:
+            n = array['shape'][1]
+        except IndexError:
+            raise ValueError(
+                "Input %s is the wrong shape for a LineString" % str(ob))
+        assert n == 2 or n == 3
+
+        # Make pointer to the coordinate array
+        try:
+            cp = cast(array['data'][0], POINTER(c_double))
+        except ArgumentError:
+            cp = array['data']
+
+        # Create a coordinate sequence
+        if update_geom is not None:
+            cs = lgeos.GEOSGeom_getCoordSeq(update_geom)
+            if n != update_ndim:
+                raise ValueError(
+                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
+                % update_ndim)
+        else:
+            cs = lgeos.GEOSCoordSeq_create(m, n)
+
+        # 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:
+                try:
+                    dz = c_double(cp[n*i+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)
+
+    except AttributeError:
+        # Fall back on list
+        m = len(ob)
+        if m < 2:
+            raise ValueError(
+                "LineStrings must have at least 2 coordinate tuples")
+        try:
+            n = len(ob[0])
+        except TypeError:
+            raise ValueError(
+                "Input %s is the wrong shape for a LineString" % str(ob))
+        assert n == 2 or n == 3
+
+        # Create a coordinate sequence
+        if update_geom is not None:
+            cs = lgeos.GEOSGeom_getCoordSeq(update_geom)
+            if n != update_ndim:
+                raise ValueError(
+                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
+                % update_ndim)
+        else:
+            cs = lgeos.GEOSCoordSeq_create(m, n)
+        
+        # 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:
+                try:
+                    dz = c_double(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
+    else:
+        return lgeos.GEOSGeom_createLineString(cs), n
+
+def update_linestring_from_py(geom, ob):
+    geos_linestring_from_py(ob, geom._geom, geom._ndim)
+
 # Test runner
 def _test():
     import doctest
     doctest.testmod()
 
-
 if __name__ == "__main__":
     _test()