shapely 1.2b4__tar.gz → 1.2b5__tar.gz

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

@@ -1,5 +1,17 @@
 All tickets are children of http://trac.gispython.org/lab/ticket.
 
+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.2b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.2b4
+Version: 1.2b5
 Summary: Planar geometries, predicates, and operations
 Home-page: http://trac.gispython.org/lab/wiki/Shapely
 Author: Sean Gillies

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

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.2b4
+Version: 1.2b5
 Summary: Planar geometries, predicates, and operations
 Home-page: http://trac.gispython.org/lab/wiki/Shapely
 Author: Sean Gillies

{Shapely-1.2b4 → Shapely-1.2b5}/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.2b5',
     requires_python     = '>=2.5,<3',
     requires_external   = 'libgeos_c (>=3.1)', 
     description         = 'Planar geometries, predicates, and operations',

{Shapely-1.2b4 → Shapely-1.2b5}/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,12 @@ 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([])
+
 
 class GeometrySequence(object):
     """

{Shapely-1.2b4 → Shapely-1.2b5}/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()

{Shapely-1.2b4 → Shapely-1.2b5}/shapely/geometry/multilinestring.py

@@ -1,4 +1,4 @@
-"""Multi-part collections of linestrings and related utilities
+"""Collections of linestrings and related utilities
 """
 
 from ctypes import c_double, c_void_p, cast, POINTER
@@ -11,47 +11,9 @@ from shapely.geometry.proxy import CachingGeometryProxy
 __all__ = ['MultiLineString', 'asMultiLineString']
 
 
-def geos_multilinestring_from_py(ob):
-    """ob must be either a sequence or array of sequences or arrays."""
-    try:
-        # From array protocol
-        array = ob.__array_interface__
-        assert len(array['shape']) == 1
-        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)()
-
-        for l in xrange(L):
-            geom, ndims = geos_linestring_from_py(array['data'][l])
-            subs[i] = cast(geom, c_void_p)
-        N = lgeos.GEOSGeom_getDimensions(subs[0])
-
-    except AttributeError:
-        # Fall back on list
-        L = len(ob)
-        N = len(ob[0][0])
-        assert L >= 1
-        assert N == 2 or N == 3
-
-        # Array of pointers to point geometries
-        subs = (c_void_p * L)()
-        
-        # add to coordinate sequence
-        for l in xrange(L):
-            geom, ndims = geos_linestring_from_py(ob[l])
-            subs[l] = cast(geom, c_void_p)
-            
-    return (lgeos.GEOSGeom_createCollection(5, subs, L), N)
-
-
 class MultiLineString(BaseMultipartGeometry):
-
-    """A one-dimensional figure comprising one or more line strings
+    """
+    A collection of one or more line strings
     
     A MultiLineString has non-zero length and zero area.
 
@@ -61,31 +23,28 @@ class MultiLineString(BaseMultipartGeometry):
         A sequence of LineStrings
     """
 
-    def __init__(self, coordinates=None):
-        """Initialize.
-
+    def __init__(self, lines=None):
+        """
         Parameters
         ----------
-        
-        coordinates : sequence
-            Contains coordinate sequences or objects that provide the numpy
-            array protocol, providing an M x 2 or M x 3 (with z) array.
+        lines : sequence
+            A sequence of line-like coordinate sequences or objects that
+            provide the numpy array interface, including instances of
+            LineString.
 
         Example
         -------
+        Construct a collection containing one line string.
 
-        >>> geom = MultiLineString( [[[0.0, 0.0], [1.0, 2.0]]] )
-        >>> geom = MultiLineString( [ array([[0.0, 0.0], [1.0, 2.0]]) ] )
-        
-        Each result in a collection containing one line string.
+          >>> lines = MultiLineString( [[[0.0, 0.0], [1.0, 2.0]]] )
         """
         super(MultiLineString, self).__init__()
 
-        if coordinates is None:
+        if lines is None:
             # allow creation of null lines, to support unpickling
             pass
         else:
-            self._geom, self._ndim = geos_multilinestring_from_py(coordinates)
+            self._geom, self._ndim = geos_multilinestring_from_py(lines)
 
     def shape_factory(self, *args):
         return LineString(*args)
@@ -99,10 +58,6 @@ class MultiLineString(BaseMultipartGeometry):
 
 
 class MultiLineStringAdapter(CachingGeometryProxy, MultiLineString):
-
-    """Adapts sequences of sequences or numpy arrays to the multilinestring
-    interface.
-    """
     
     context = None
     _owned = False
@@ -125,15 +80,54 @@ class MultiLineStringAdapter(CachingGeometryProxy, MultiLineString):
 
 
 def asMultiLineString(context):
-    """Factory for MultiLineStringAdapter instances."""
+    """Adapts a sequence of objects to the MultiLineString interface"""
     return MultiLineStringAdapter(context)
 
 
+def geos_multilinestring_from_py(ob):
+    # ob must be either a sequence or array of sequences or arrays
+    try:
+        # From array protocol
+        array = ob.__array_interface__
+        assert len(array['shape']) == 1
+        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)()
+
+        for l in xrange(L):
+            geom, ndims = geos_linestring_from_py(array['data'][l])
+            subs[i] = cast(geom, c_void_p)
+        N = lgeos.GEOSGeom_getDimensions(subs[0])
+    except (NotImplementedError, AttributeError):
+        obs = getattr(ob, 'geoms', ob)
+        L = len(obs)
+        exemplar = obs[0]
+        try:
+            N = len(exemplar[0])
+        except TypeError:
+            N = exemplar._ndim
+        assert L >= 1
+        assert N == 2 or N == 3
+
+        # Array of pointers to point geometries
+        subs = (c_void_p * L)()
+        
+        # add to coordinate sequence
+        for l in xrange(L):
+            geom, ndims = geos_linestring_from_py(obs[l])
+            subs[l] = cast(geom, c_void_p)
+            
+    return (lgeos.GEOSGeom_createCollection(5, subs, L), N)
+
 # Test runner
 def _test():
     import doctest
     doctest.testmod()
 
-
 if __name__ == "__main__":
     _test()