shapely 1.0rc2__tar.gz → 1.0.2__tar.gz

Shapely-1.0.2/CHANGES.txt

@@ -0,0 +1,7 @@
+All ticket numbers are rooted at http://trac.gispython.org/projects/PCL/ticket/
+
+1.0.2: 26 February 2008
+-----------------------
+- Fix loss of dimensionality in polygon rings (#155).
+
+

Shapely-1.0.2/HISTORY.txt

@@ -0,0 +1,24 @@
+All ticket numbers are rooted at http://trac.gispython.org/projects/PCL/ticket/
+
+1.0.1: 8 February 2008
+----------------------
+- Allow chaining expressions involving coordinate sequences and geometry parts
+  (#151).
+- Protect against abnormal use of coordinate accessors (#152).
+- Coordinate sequences now implement the numpy array protocol (#153).
+
+
+1.0: 18 January 2008
+--------------------
+- Final release.
+
+
+1.0 RC2: 16 January 2008
+------------------------
+- Added temporary solution for #149.
+
+
+1.0 RC1: 14 January 2008
+------------------------
+- First release candidate
+

{Shapely-1.0rc2 → Shapely-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.0rc2
+Version: 1.0.2
 Summary: Geospatial geometries, predicates, and operations
 Home-page: http://trac.gispython.org/projects/PCL/wiki/Shapely
 Author: Sean Gillies
@@ -9,10 +9,11 @@ License: BSD
 Description: Shapely
         =======
         
-        Shapely is a Python package for programming with 2D geospatial geometries. It
-        is based on GEOS (http://geos.refractions.net). Shapely 1.0 is ignorant about
-        coordinate and reference systems. Projection responsibility is left to specific
-        applications. For more information, see:
+        Shapely is a Python package for manipulation and analysis of 2D geospatial
+        geometries. It is based on GEOS (http://geos.refractions.net).  Shapely 1.0 is
+        not concerned with data formats or coordinate reference systems.
+        Responsibility for reading and writing data and projecting coordinates is left
+        to other packages like WorldMill_ and pyproj_. For more information, see:
         
         * Shapely wiki_
         * Shapely manual_
@@ -20,6 +21,13 @@ Description: Shapely
         Shapely requires Python 2.4+. (I've also begun to port it to Python 3.0:
         http://zcologia.com/news/564/shapely-for-python-3-0/.)
         
+        See also CHANGES.txt_ and HISTORY.txt_.
+        
+        .. _CHANGES.txt: http://trac.gispython.org/projects/PCL/browser/Shapely/trunk/CHANGES.txt
+        .. _HISTORY.txt: http://trac.gispython.org/projects/PCL/browser/Shapely/trunk/HISTORY.txt
+        .. _WorldMill: http://pypi.python.org/pypi/WorldMill
+        .. _pyproj: http://pypi.python.org/pypi/pyproj
+        
         
         Dependencies
         ------------

{Shapely-1.0rc2 → Shapely-1.0.2}/README.txt

@@ -1,10 +1,11 @@
 Shapely
 =======
 
-Shapely is a Python package for programming with 2D geospatial geometries. It
-is based on GEOS (http://geos.refractions.net). Shapely 1.0 is ignorant about
-coordinate and reference systems. Projection responsibility is left to specific
-applications. For more information, see:
+Shapely is a Python package for manipulation and analysis of 2D geospatial
+geometries. It is based on GEOS (http://geos.refractions.net).  Shapely 1.0 is
+not concerned with data formats or coordinate reference systems.
+Responsibility for reading and writing data and projecting coordinates is left
+to other packages like WorldMill_ and pyproj_. For more information, see:
 
 * Shapely wiki_
 * Shapely manual_
@@ -12,6 +13,13 @@ applications. For more information, see:
 Shapely requires Python 2.4+. (I've also begun to port it to Python 3.0:
 http://zcologia.com/news/564/shapely-for-python-3-0/.)
 
+See also CHANGES.txt_ and HISTORY.txt_.
+
+.. _CHANGES.txt: http://trac.gispython.org/projects/PCL/browser/Shapely/trunk/CHANGES.txt
+.. _HISTORY.txt: http://trac.gispython.org/projects/PCL/browser/Shapely/trunk/HISTORY.txt
+.. _WorldMill: http://pypi.python.org/pypi/WorldMill
+.. _pyproj: http://pypi.python.org/pypi/pyproj
+
 
 Dependencies
 ------------

{Shapely-1.0rc2 → Shapely-1.0.2}/Shapely.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.0rc2
+Version: 1.0.2
 Summary: Geospatial geometries, predicates, and operations
 Home-page: http://trac.gispython.org/projects/PCL/wiki/Shapely
 Author: Sean Gillies
@@ -9,10 +9,11 @@ License: BSD
 Description: Shapely
         =======
         
-        Shapely is a Python package for programming with 2D geospatial geometries. It
-        is based on GEOS (http://geos.refractions.net). Shapely 1.0 is ignorant about
-        coordinate and reference systems. Projection responsibility is left to specific
-        applications. For more information, see:
+        Shapely is a Python package for manipulation and analysis of 2D geospatial
+        geometries. It is based on GEOS (http://geos.refractions.net).  Shapely 1.0 is
+        not concerned with data formats or coordinate reference systems.
+        Responsibility for reading and writing data and projecting coordinates is left
+        to other packages like WorldMill_ and pyproj_. For more information, see:
         
         * Shapely wiki_
         * Shapely manual_
@@ -20,6 +21,13 @@ Description: Shapely
         Shapely requires Python 2.4+. (I've also begun to port it to Python 3.0:
         http://zcologia.com/news/564/shapely-for-python-3-0/.)
         
+        See also CHANGES.txt_ and HISTORY.txt_.
+        
+        .. _CHANGES.txt: http://trac.gispython.org/projects/PCL/browser/Shapely/trunk/CHANGES.txt
+        .. _HISTORY.txt: http://trac.gispython.org/projects/PCL/browser/Shapely/trunk/HISTORY.txt
+        .. _WorldMill: http://pypi.python.org/pypi/WorldMill
+        .. _pyproj: http://pypi.python.org/pypi/pyproj
+        
         
         Dependencies
         ------------

{Shapely-1.0rc2 → Shapely-1.0.2}/Shapely.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ tests/Point.txt
 tests/Polygon.txt
 tests/Predicates.txt
 tests/__init__.py
+tests/attribute-chains.txt
 tests/binascii_hex.txt
 tests/invalid_intersection.txt
 tests/rungrind.dist

Shapely-1.0.2/Shapely.egg-info/requires.txt

@@ -0,0 +1 @@
+setuptools

{Shapely-1.0rc2 → Shapely-1.0.2}/setup.py

@@ -11,7 +11,7 @@ if version_info[:2] < (2,5):
 readme_text = file('README.txt', 'rb').read()
 
 setup(name          = 'Shapely',
-      version       = '1.0rc2',
+      version       = '1.0.2',
       description   = 'Geospatial geometries, predicates, and operations',
       license       = 'BSD',
       keywords      = 'geometry topology',

{Shapely-1.0rc2 → Shapely-1.0.2}/setup_windows.py

@@ -11,7 +11,7 @@ if version_info[:2] < (2,5):
 readme_text = file('README.txt', 'rb').read()
 
 setup(name          = 'Shapely',
-      version       = '1.0rc2',
+      version       = '1.0.2',
       description   = 'Geospatial geometries, predicates, and operations',
       license       = 'BSD',
       keywords      = 'geometry topology',

{Shapely-1.0rc2 → Shapely-1.0.2}/shapely/geometry/base.py

@@ -41,24 +41,32 @@ def geom_factory(g):
         [geom_type],
         )
     ob.__class__ = getattr(mod, geom_type)
-    ob._geom = g
+    ob.__geom__ = g
     ob._ndim = 2 # callers should be all from 2D worlds
     return ob
 
 
 class CoordinateSequence(object):
-
+    
+    _geom = None
     _cseq = None
     _ndim = None
     _length = 0
     index = 0
+    __p__ = None
 
-    def __init__(self, geom):
-        self._cseq = lgeos.GEOSGeom_getCoordSeq(geom._geom)
-        self._ndim = geom._ndim
+    def __init__(self, parent):
+        self.__p__ = parent
+        self._geom = parent._geom
+        self._ndim = parent._ndim
+        self.update_cseq()
 
+    def update_cseq(self):
+        self._cseq = lgeos.GEOSGeom_getCoordSeq(self._geom)
+        
     def __iter__(self):
         self.index = 0
+        self.update_cseq()
         self._length = self.__len__()
         return self
 
@@ -86,6 +94,7 @@ class CoordinateSequence(object):
         return cs_len.value
     
     def __getitem__(self, i):
+        self.update_cseq()
         M = self.__len__()
         if i + M < 0 or i >= M:
             raise IndexError, "index out of range"
@@ -104,19 +113,58 @@ class CoordinateSequence(object):
         else:
             return (dx.value, dy.value)
 
+    @property
+    def ctypes(self):
+        self.update_cseq()
+        n = self._ndim
+        m = self.__len__()
+        array_type = c_double * (m * n)
+        data = array_type()
+        temp = c_double()
+
+        for i in xrange(m):
+            lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(temp))
+            data[n*i] = temp.value
+            lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(temp))
+            data[n*i+1] = temp.value
+            if n == 3: # TODO: use hasz
+                lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(temp))
+                data[n*i+2] = temp.value
+        return data
+
+    def array_interface(self):
+        """Provide the Numpy array protocol."""
+        if sys.byteorder == 'little':
+            typestr = '<f8'
+        elif sys.byteorder == 'big':
+            typestr = '>f8'
+        else:
+            raise ValueError, \
+            "Unsupported byteorder: neither little nor big-endian"
+        ai = {
+            'version': 3,
+            'typestr': typestr,
+            'data': self.ctypes,
+            }
+        ai.update({'shape': (len(self), self._ndim)})
+        return ai
+    __array_interface__ = property(array_interface)
+
 
 class GeometrySequence(object):
 
     _factory = None
     _geom = None
+    __p__ = None
     _ndim = None
     _index = 0
     _length = 0
 
-    def __init__(self, geom, type):
+    def __init__(self, parent, type):
         self._factory = type
-        self._geom = geom._geom
-        self._ndim = geom._ndim
+        self.__p__ = parent
+        self._geom = parent._geom
+        self._ndim = parent._ndim
 
     def __iter__(self):
         self._index = 0
@@ -182,18 +230,18 @@ class BaseGeometry(object):
     """Provides GEOS spatial predicates and topological operations.
     """
 
-    __geom = None # See _geom property below
+    __geom__ = None # See _geom property below
     _ctypes_data = None
     _ndim = None
     _crs = None
     _owned = False
 
     def __init__(self):
-        self.__geom = None
+        self.__geom__ = None
 
     def __del__(self):
-        if self.__geom is not None and not self._owned:
-            lgeos.GEOSGeom_destroy(self.__geom)
+        if self.__geom__ is not None and not self._owned:
+            lgeos.GEOSGeom_destroy(self.__geom__)
 
     def __str__(self):
         return self.to_wkt()
@@ -210,7 +258,7 @@ class BaseGeometry(object):
         return (self.__class__, (), self.to_wkb())
 
     def __setstate__(self, state):
-        self.__geom = lgeos.GEOSGeomFromWKB_buf(
+        self.__geom__ = lgeos.GEOSGeomFromWKB_buf(
                         c_char_p(state), 
                         c_size_t(len(state))
                         )
@@ -218,11 +266,13 @@ class BaseGeometry(object):
     # _geom has been made a property with the GEOS geometry pointer stored
     # in __geom so that geometries and geometry adapters can share __del__
 
-    def get_geom(self):
-        return self.__geom
-    def set_geom(self, val):
-        self.__geom = val
-    _geom = property(get_geom, set_geom)
+    def _get_geom(self):
+        return self.__geom__
+
+    def _set_geom(self, val):
+        self.__geom__ = val
+    
+    _geom = property(_get_geom, _set_geom)
 
     # Array and ctypes interfaces
 
@@ -253,14 +303,14 @@ class BaseGeometry(object):
         raise NotImplementedError
 
     @exceptNull
-    def get_coords(self):
+    def _get_coords(self):
         return CoordinateSequence(self)
 
-    def set_coords(self, ob):
+    def _set_coords(self, ob):
         raise NotImplementedError, \
             "set_coords must be provided by derived classes"
 
-    coords = property(get_coords, set_coords)
+    coords = property(_get_coords, _set_coords)
 
     # Python feature protocol
 

{Shapely-1.0rc2 → Shapely-1.0.2}/shapely/geometry/linestring.py

@@ -138,40 +138,23 @@ class LineString(BaseGeometry):
     @exceptNull
     def ctypes(self):
         if not self._ctypes_data:
-            cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
-            cs_len = c_int(0)
-            lgeos.GEOSCoordSeq_getSize(cs, byref(cs_len))
-            temp = c_double()
-            n = self._ndim
-            m = cs_len.value
-            array_type = c_double * (m * n)
-            data = array_type()
-            for i in xrange(m):
-                lgeos.GEOSCoordSeq_getX(cs, i, byref(temp))
-                data[n*i] = temp.value
-                lgeos.GEOSCoordSeq_getY(cs, i, byref(temp))
-                data[n*i+1] = temp.value
-                if n == 3: # TODO: use hasz
-                    lgeos.GEOSCoordSeq_getZ(cs, i, byref(temp))
-                    data[n*i+2] = temp.value
-            self._ctypes_data = data
+            self._ctypes_data = self.coords.ctypes
         return self._ctypes_data
 
     def array_interface(self):
         """Provide the Numpy array protocol."""
-        ai = self.array_interface_base
-        ai.update({'shape': (len(self.coords), self._ndim)})
-        return ai
+        return self.coords.array_interface()
+    
     __array_interface__ = property(array_interface)
 
     # Coordinate access
 
-    def set_coords(self, coordinates):
+    def _set_coords(self, coordinates):
         if self._geom is None:
             self._init_geom(coordinates)
         update_linestring_from_py(self, coordinates)
 
-    coords = property(BaseGeometry.get_coords, set_coords)
+    coords = property(BaseGeometry._get_coords, _set_coords)
 
 
 class LineStringAdapter(LineString):
@@ -181,7 +164,7 @@ class LineStringAdapter(LineString):
     """
     
     context = None
-    __geom = None
+    #__geom = None
     _owned = False
 
     def __init__(self, context):
@@ -202,10 +185,10 @@ class LineStringAdapter(LineString):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom, n = geos_linestring_from_py(self.context)
-        return self.__geom
+        if self.__geom__ is not None:
+            lgeos.GEOSGeom_destroy(self.__geom__)
+        self.__geom__, n = geos_linestring_from_py(self.context)
+        return self.__geom__
 
     @property
     def __array_interface__(self):
@@ -215,7 +198,13 @@ class LineStringAdapter(LineString):
         except AttributeError:
             return self.array_interface()
 
-    coords = property(BaseGeometry.get_coords)
+    _get_coords = BaseGeometry._get_coords
+
+    def _set_coords(self, ob):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
+    coords = property(_get_coords)
 
 
 def asLineString(context):

{Shapely-1.0rc2 → Shapely-1.0.2}/shapely/geometry/multilinestring.py

@@ -96,6 +96,14 @@ class MultiLineString(BaseGeometry):
         raise NotImplementedError, \
         "Multi-part geometries do not themselves provide the array interface"
 
+    def _get_coords(self):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
+    def _set_coords(self, ob):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
     @property
     def coords(self):
         raise NotImplementedError, \
@@ -114,7 +122,7 @@ class MultiLineStringAdapter(MultiLineString):
     """
     
     context = None
-    __geom = None
+    #__geom = None
     _owned = False
 
     def __init__(self, context):
@@ -135,10 +143,10 @@ class MultiLineStringAdapter(MultiLineString):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom = geos_multilinestring_from_py(self.context)[0]
-        return self.__geom
+        if self.__geom__ is not None:
+            lgeos.GEOSGeom_destroy(self.__geom__)
+        self.__geom__ = geos_multilinestring_from_py(self.context)[0]
+        return self.__geom__
 
 
 def asMultiLineString(context):

{Shapely-1.0rc2 → Shapely-1.0.2}/shapely/geometry/multipoint.py

@@ -118,6 +118,14 @@ class MultiPoint(BaseGeometry):
         return ai
     __array_interface__ = property(array_interface)
 
+    def _get_coords(self):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
+    def _set_coords(self, ob):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
     @property
     def coords(self):
         raise NotImplementedError, \
@@ -136,7 +144,7 @@ class MultiPointAdapter(MultiPoint):
     """
     
     context = None
-    __geom = None
+    #__geom__ = None
     _owned = False
 
     def __init__(self, context):
@@ -157,10 +165,10 @@ class MultiPointAdapter(MultiPoint):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom, n = geos_multipoint_from_py(self.context)
-        return self.__geom
+        if self.__geom__ is not None:
+            lgeos.GEOSGeom_destroy(self.__geom__)
+        self.__geom__, n = geos_multipoint_from_py(self.context)
+        return self.__geom__
 
     @property
     def __array_interface__(self):

{Shapely-1.0rc2 → Shapely-1.0.2}/shapely/geometry/multipolygon.py

@@ -82,6 +82,14 @@ class MultiPolygon(BaseGeometry):
         raise NotImplementedError, \
         "Multi-part geometries do not themselves provide the array interface"
 
+    def _get_coords(self):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
+    def _set_coords(self, ob):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
     @property
     def coords(self):
         raise NotImplementedError, \
@@ -100,7 +108,7 @@ class MultiPolygonAdapter(MultiPolygon):
     """
     
     context = None
-    __geom = None
+    #__geom = None
     _owned = False
 
     def __init__(self, context):
@@ -121,10 +129,10 @@ class MultiPolygonAdapter(MultiPolygon):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom = geos_multipolygon_from_py(self.context)[0]
-        return self.__geom
+        if self.__geom__ is not None:
+            lgeos.GEOSGeom_destroy(self.__geom__)
+        self.__geom__ = geos_multipolygon_from_py(self.context)[0]
+        return self.__geom__
 
 
 def asMultiPolygon(context):

{Shapely-1.0rc2 → Shapely-1.0.2}/shapely/geometry/point.py

@@ -190,13 +190,13 @@ class Point(BaseGeometry):
 
     # Coordinate access
 
-    def set_coords(self, coordinates):
+    def _set_coords(self, coordinates):
         if self._geom is None:
             self._init_geom(coordinates)
         else:
             update_point_from_py(self, coordinates)
 
-    coords = property(BaseGeometry.get_coords, set_coords)
+    coords = property(BaseGeometry._get_coords, _set_coords)
 
 
 class PointAdapter(Point):
@@ -241,7 +241,13 @@ class PointAdapter(Point):
         except AttributeError:
             return self.array_interface()
 
-    coords = property(BaseGeometry.get_coords)
+    _get_coords = BaseGeometry._get_coords
+
+    def _set_coords(self, ob):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
+    coords = property(_get_coords)
 
 
 def asPoint(context):

{Shapely-1.0rc2 → Shapely-1.0.2}/shapely/geometry/polygon.py

@@ -141,7 +141,8 @@ class LinearRing(LineString):
     """
 
     _ndim = 2
-    __geom = None
+    __geom__ = None
+    __p__ = None
     _owned = False
 
     def __init__(self, coordinates=None):
@@ -171,7 +172,7 @@ class LinearRing(LineString):
             # allow creation of null lines, to support unpickling
             pass
         else:
-            self._geom, self._ndims = geos_linearring_from_py(coordinates)
+            self._geom, self._ndim = geos_linearring_from_py(coordinates)
 
     @property
     def __geo_interface__(self):
@@ -182,24 +183,27 @@ class LinearRing(LineString):
 
     # Coordinate access
 
-    def set_coords(self, coordinates):
+    _get_coords = BaseGeometry._get_coords
+
+    def _set_coords(self, coordinates):
         if self._geom is None:
             self._init_geom(coordinates)
         update_linearring_from_py(self, coordinates)
 
-    coords = property(BaseGeometry.get_coords, set_coords)
+    coords = property(_get_coords, _set_coords)
 
 
 class LinearRingAdapter(LineStringAdapter):
 
     context = None
-    __geom = None
+    __geom__ = None
+    __p__ = None
     _owned = False
 
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        if self.__geom is not None:
+        if self.__geom__ is not None:
             lgeos.GEOSGeom_destroy(self.__geom)
         self.__geom, n = geos_linearring_from_py(self.context)
         return self.__geom
@@ -211,7 +215,7 @@ class LinearRingAdapter(LineStringAdapter):
             'coordinates': tuple(self.coords)
             }
 
-    coords = property(BaseGeometry.get_coords)
+    coords = property(BaseGeometry._get_coords)
 
 
 def asLinearRing(context):
@@ -222,13 +226,15 @@ class InteriorRingSequence(object):
 
     _factory = None
     _geom = None
+    __p__ = None
     _ndim = None
     _index = 0
     _length = 0
 
-    def __init__(self, geom):
-        self._geom = geom._geom
-        self._ndim = geom._ndim
+    def __init__(self, parent):
+        self.__p__ = parent
+        self._geom = parent._geom
+        self._ndim = parent._ndim
 
     def __iter__(self):
         self._index = 0
@@ -272,7 +278,7 @@ class InteriorRingSequence(object):
 
 def geos_polygon_from_py(shell, holes=None):
     if shell is not None:
-        geos_shell, ndims = geos_linearring_from_py(shell)
+        geos_shell, ndim = geos_linearring_from_py(shell)
         if holes:
             ob = holes
             L = len(ob)
@@ -288,7 +294,7 @@ def geos_polygon_from_py(shell, holes=None):
     
             # add to coordinate sequence
             for l in xrange(L):
-                geom, ndims = geos_linearring_from_py(ob[l])
+                geom, ndim = geos_linearring_from_py(ob[l])
                 geos_holes[l] = cast(geom, c_void_p)
 
         else:
@@ -301,7 +307,7 @@ def geos_polygon_from_py(shell, holes=None):
                         geos_holes,
                         L
                         ),
-            ndims
+            ndim
             )
 
 class Polygon(BaseGeometry):
@@ -312,7 +318,7 @@ class Polygon(BaseGeometry):
     _exterior = None
     _interiors = []
     _ndim = 2
-    __geom = None
+    __geom__ = None
     _owned = False
 
     def __init__(self, shell=None, holes=None):
@@ -333,7 +339,7 @@ class Polygon(BaseGeometry):
         BaseGeometry.__init__(self)
 
         if shell is not None:
-            self._geom, self._ndims = geos_polygon_from_py(shell, holes)
+            self._geom, self._ndim = geos_polygon_from_py(shell, holes)
 
     @property
     @exceptNull
@@ -344,6 +350,8 @@ class Polygon(BaseGeometry):
             ring = lgeos.GEOSGetExteriorRing(self._geom)
             self._exterior = LinearRing()
             self._exterior._geom = ring
+            # The ring needs to hold an extra ref to the polygon
+            self.__p__ = self
             self._exterior._owned = True
         return self._exterior
 
@@ -363,6 +371,14 @@ class Polygon(BaseGeometry):
         raise NotImplementedError, \
         "A polygon does not itself provide the array interface. Its rings do."
 
+    def _get_coords(self):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
+    def _set_coords(self, ob):
+        raise NotImplementedError, \
+        "Component rings have coordinate sequences, but the polygon does not"
+
     @property
     def coords(self):
         raise NotImplementedError, \
@@ -386,7 +402,7 @@ class PolygonAdapter(Polygon):
     """
     
     context = None
-    __geom = None
+    __geom__ = None
     _owned = False
 
     def __init__(self, shell, holes=None):
@@ -408,10 +424,10 @@ class PolygonAdapter(Polygon):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom = geos_polygon_from_py(self.shell, self.holes)[0]  
-        return self.__geom
+        if self.__geom__ is not None:
+            lgeos.GEOSGeom_destroy(self.__geom__)
+        self.__geom__ = geos_polygon_from_py(self.shell, self.holes)[0]  
+        return self.__geom__
 
 
 def asPolygon(shell, holes=None):

{Shapely-1.0rc2 → Shapely-1.0.2}/shapely/geos.py

@@ -24,15 +24,27 @@ if sys.platform == 'win32':
         except WindowsError:
             # XXX: See http://trac.gispython.org/projects/PCL/ticket/149
             pass
-
 elif sys.platform == 'darwin':
-    lgeos = CDLL(find_library('geos_c'))
+    lib = find_library('geos_c')
+    if lib is None:
+        ## try a few more locations
+        lib_paths = [
+            # The Framework build from Kyng Chaos:
+            "/Library/Frameworks/GEOS.framework/Versions/Current/GEOS",
+        ]
+        for path in lib_paths:
+            if os.path.exists(path):
+                lib = path
+                break
+            else:
+                raise ImportError, "Could not find geos_c library"
+    lgeos = CDLL(lib)
     free = CDLL(find_library('libc')).free
 else:
     # Try the major versioned name first, falling back on the unversioned name.
     try:
         lgeos = CDLL('libgeos_c.so.1')
-    except ImportError:
+    except (OSError, ImportError):
         lgeos = CDLL('libgeos_c.so')
     except:
         raise

Shapely-1.0.2/tests/LineString.txt

@@ -0,0 +1,130 @@
+LineStrings
+===========
+
+Initialization
+--------------
+
+    >>> from shapely.geometry import LineString
+
+Construct from a numpy array
+
+    >>> from numpy import array
+    >>> line = LineString(array([[0.0, 0.0], [1.0, 2.0]]))
+    >>> len(line.coords)
+    2
+    >>> line.wkt
+    'LINESTRING (0.0000000000000000 0.0000000000000000, 1.0000000000000000 2.0000000000000000)'
+
+From coordinate tuples
+
+    >>> line = LineString(((1.0, 2.0), (3.0, 4.0)))
+    >>> len(line.coords)
+    2
+    >>> line.wkt
+    'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
+
+
+Numpy Support
+-------------
+
+    >>> from numpy import asarray
+    >>> la = asarray(line)
+    >>> la
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+    >>> la[0]
+    array([ 1.,  2.])
+
+Coordinate sequences can be adapted as well
+
+    >>> asarray(line.coords)
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+
+Bounds
+------
+
+    >>> line.bounds
+    (1.0, 2.0, 3.0, 4.0)
+
+Coordinate Access
+-----------------
+
+    >>> tuple(line.coords)
+    ((1.0, 2.0), (3.0, 4.0))
+
+    >>> line.coords[0]
+    (1.0, 2.0)
+    >>> line.coords[1]
+    (3.0, 4.0)
+    >>> line.coords[2]
+    Traceback (most recent call last):
+    ...
+    IndexError: index out of range
+
+Geo interface
+-------------
+
+    >>> line.__geo_interface__
+    {'type': 'LineString', 'coordinates': ((1.0, 2.0), (3.0, 4.0))}
+
+
+Coordinate modification
+-----------------------
+
+    >>> line.coords = ((-1.0, -1.0), (1.0, 1.0))
+    >>> line.__geo_interface__
+    {'type': 'LineString', 'coordinates': ((-1.0, -1.0), (1.0, 1.0))}
+
+
+Adapter
+-------
+
+    >>> from shapely.geometry import asLineString
+
+    Adapt a Numpy array to a line string
+
+    >>> a = array([[1.0, 2.0], [3.0, 4.0]])
+    >>> la = asLineString(a)
+    >>> la.context
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+
+    >>> la.wkt
+    'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
+
+Now, the inverse
+
+    >>> la.__array_interface__ == la.context.__array_interface__
+    True
+    >>> as = asarray(la)
+    >>> as
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+
+Adapt a coordinate list to a line string
+
+    >>> coords = [[5.0, 6.0], [7.0, 8.0]]
+    >>> la = asLineString(coords)
+    >>> la.wkt
+    'LINESTRING (5.0000000000000000 6.0000000000000000, 7.0000000000000000 8.0000000000000000)'
+
+Test Non-operability of Null geometry
+
+    >>> l_null = LineString()
+    >>> l_null.wkt # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    ValueError: Null geometry supports no operations
+
+    >>> l_null.length # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+    ...
+    ValueError: Null geometry supports no operations
+
+Check that we can set coordinates of a null geometry
+
+    >>> l_null.coords = [(0, 0), (1, 1)]
+    >>> print l_null.length # doctest: +ELLIPSIS
+    1.414...
+

{Shapely-1.0rc2 → Shapely-1.0.2}/tests/Polygon.txt

@@ -88,6 +88,17 @@ Interior rings (holes)
   ...
   IndexError: index out of range
 
+Coordinate getters and setters raise exceptions
+
+  >>> polygon._get_coords()
+  Traceback (most recent call last):
+  ...
+  NotImplementedError: Component rings have coordinate sequences, but the polygon does not
+  >>> polygon.coords
+  Traceback (most recent call last):
+  ...
+  NotImplementedError: Component rings have coordinate sequences, but the polygon does not
+
 
 Geo interface
 -------------
@@ -128,3 +139,4 @@ Check that we can set coordinates of a null geometry
   >>> print r_null.length # doctest: +ELLIPSIS
   3.414...
 
+

Shapely-1.0.2/tests/attribute-chains.txt

@@ -0,0 +1,27 @@
+Attribute Chaining
+==================
+
+See also ticket #151.
+
+    >>> from shapely.geometry import Polygon
+    >>> p = Polygon(((0.0, 0.0), (0.0, 1.0), (-1.0, 1.0), (-1.0, 0.0)))
+    >>> list(p.boundary.coords)
+    [(0.0, 0.0), (0.0, 1.0), (-1.0, 1.0), (-1.0, 0.0), (0.0, 0.0)]
+
+    >>> print list(p.buffer(1).exterior.coords)
+    [(-0.99999999999999989, 2.0), (0.0, 2.0)...
+
+Test chained access to interiors
+
+    >>> p = Polygon(
+    ...         ((0.0, 0.0), (0.0, 1.0), (-1.0, 1.0), (-1.0, 0.0)),
+    ...         [((-0.25, 0.25), (-0.25, 0.75), (-0.75, 0.75), (-0.75, 0.25))]
+    ...     )
+    >>> p.area
+    0.75
+    >>> print list(p.interiors[0].coords)
+    [(-0.25, 0.25), (-0.25, 0.75), (-0.75, 0.75), (-0.75, 0.25), (-0.25, 0.25)]
+    >>> print list(p.interiors[0].buffer(1).exterior.coords)
+    [(-0.24999999999999986, -0.75), (-0.25, -0.75)...
+    
+

{Shapely-1.0rc2 → Shapely-1.0.2}/tests/test_doctests.py

@@ -30,5 +30,5 @@ def test_suite():
          in list_doctests()])
 
 if __name__ == "__main__":
-    runner = unittest.TextTestRunner()
+    runner = unittest.TextTestRunner(verbosity=1)
     runner.run(test_suite())

Shapely-1.0rc2/HISTORY.txt

@@ -1,11 +0,0 @@
-All ticket numbers are rooted at http://trac.gispython.org/projects/PCL/ticket/
-
-1.0 RC2: 16 January 2008
-------------------------
-- Added temporary solution for #149.
-
-
-1.0 RC1: 14 January 2008
-------------------------
-- First release candidate
-

Shapely-1.0rc2/Shapely.egg-info/requires.txt

@@ -1,2 +0,0 @@
-setuptools
-ctypes

Shapely-1.0rc2/tests/LineString.txt

@@ -1,124 +0,0 @@
-LineStrings
-===========
-
-Initialization
---------------
-
-  >>> from shapely.geometry import LineString
-
-Construct from a numpy array
-
-  >>> from numpy import array
-  >>> line = LineString(array([[0.0, 0.0], [1.0, 2.0]]))
-  >>> len(line.coords)
-  2
-  >>> line.wkt
-  'LINESTRING (0.0000000000000000 0.0000000000000000, 1.0000000000000000 2.0000000000000000)'
-
-From coordinate tuples
-
-  >>> line = LineString(((1.0, 2.0), (3.0, 4.0)))
-  >>> len(line.coords)
-  2
-  >>> line.wkt
-  'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
-
-
-Numpy Support
--------------
-
-  >>> from numpy import asarray
-  >>> la = asarray(line)
-  >>> la
-  array([[ 1.,  2.],
-         [ 3.,  4.]])
-  >>> la[0]
-  array([ 1.,  2.])
-
-Bounds
-------
-
-  >>> line.bounds
-  (1.0, 2.0, 3.0, 4.0)
-
-Coordinate Access
------------------
-
-  >>> tuple(line.coords)
-  ((1.0, 2.0), (3.0, 4.0))
-
-  >>> line.coords[0]
-  (1.0, 2.0)
-  >>> line.coords[1]
-  (3.0, 4.0)
-  >>> line.coords[2]
-  Traceback (most recent call last):
-  ...
-  IndexError: index out of range
-
-Geo interface
--------------
-
-  >>> line.__geo_interface__
-  {'type': 'LineString', 'coordinates': ((1.0, 2.0), (3.0, 4.0))}
-
-
-Coordinate modification
------------------------
-
-  >>> line.coords = ((-1.0, -1.0), (1.0, 1.0))
-  >>> line.__geo_interface__
-  {'type': 'LineString', 'coordinates': ((-1.0, -1.0), (1.0, 1.0))}
-
-
-Adapter
--------
-
-  >>> from shapely.geometry import asLineString
-
-  Adapt a Numpy array to a line string
-
-  >>> a = array([[1.0, 2.0], [3.0, 4.0]])
-  >>> la = asLineString(a)
-  >>> la.context
-  array([[ 1.,  2.],
-         [ 3.,  4.]])
-
-  >>> la.wkt
-  'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
-
-  Now, the inverse
-
-  >>> la.__array_interface__ == la.context.__array_interface__
-  True
-  >>> as = asarray(la)
-  >>> as
-  array([[ 1.,  2.],
-         [ 3.,  4.]])
-
-  Adapt a coordinate list to a line string
-
-  >>> coords = [[5.0, 6.0], [7.0, 8.0]]
-  >>> la = asLineString(coords)
-  >>> la.wkt
-  'LINESTRING (5.0000000000000000 6.0000000000000000, 7.0000000000000000 8.0000000000000000)'
-
-Test Non-operability of Null geometry
-
-  >>> l_null = LineString()
-  >>> l_null.wkt # doctest: +ELLIPSIS
-  Traceback (most recent call last):
-  ...
-  ValueError: Null geometry supports no operations
-
-  >>> l_null.length # doctest: +ELLIPSIS
-  Traceback (most recent call last):
-  ...
-  ValueError: Null geometry supports no operations
-
-Check that we can set coordinates of a null geometry
-
-  >>> l_null.coords = [(0, 0), (1, 1)]
-  >>> print l_null.length # doctest: +ELLIPSIS
-  1.414...
-