shapely 1.0b3__py2.4.egg → 1.0rc1__py2.4.egg

EGG-INFO/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.0b3
+Version: 1.0rc1
 Summary: Geospatial geometries, predicates, and operations
 Home-page: http://trac.gispython.org/projects/PCL/wiki/Shapely
 Author: Sean Gillies
@@ -9,8 +9,8 @@ License: BSD
 Description: Shapely
         =======
         
-        Shapely is a Python package for programming with geospatial geometries. It is
-        based on GEOS (http://geos.refractions.net). Shapely 1.0 is ignorant about
+        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:
         
@@ -20,14 +20,16 @@ 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/.)
         
+        
         Dependencies
         ------------
         
-        * libgeos_c (2.2.3, also reported to work with 3.0)
+        * libgeos_c (2.2.3 or 3.0.0+)
         * Python ctypes_ (standard in Python 2.5+)
         
         .. _ctypes: http://pypi.python.org/pypi/ctypes/
         
+        
         Installation
         ------------
         
@@ -39,26 +41,29 @@ Description: Shapely
         
         $ sudo python setup.py install
         
-        or by using the development buildout, which also provides libgeos_c::
+        or by using the development buildout on Linux, which also provides libgeos_c::
         
         $ svn co http://svn.gispython.org/svn/gispy/buildout/shapely.buildout/trunk shapely.buildout
         $ cd shapely.buildout
         $ python bootstrap.py
         $ ./bin/buildout
         
+        
         Usage
         -----
         
-        Buffer a point::
+        To buffer a point::
         
         >>> from shapely.geometry import Point
         >>> point = Point(-106.0, 40.0) # longitude, latitude
         >>> point.buffer(10.0)
         <shapely.geometry.polygon.Polygon object at ...>
         
-        See Operations.txt and Predicates.txt under tests/ for more examples of the
-        spatial operations and predicates provided by Shapely. Also see Point.txt,
-        LineString.txt, etc for examples of the geometry APIs.
+        See the manual_ for comprehensive examples of usage. See also Operations.txt
+        and Predicates.txt under tests/ for more examples of the spatial operations and
+        predicates provided by Shapely. See also Point.txt, LineString.txt, etc for
+        examples of the geometry APIs.
+        
         
         Numpy integration
         -----------------
@@ -80,6 +85,7 @@ Description: Shapely
         >>> line.wkt
         'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
         
+        
         Python Geo Interface
         --------------------
         
@@ -107,6 +113,7 @@ Description: Shapely
         See http://trac.gispython.org/projects/PCL/wiki/PythonGeoInterface for more
         details on the interface.
         
+        
         Testing
         -------
         
@@ -116,7 +123,11 @@ Description: Shapely
         $ python point.py
         
         There are also two test runners under tests/. test_doctests.py requires
-        zope.testing. runalldoctests.py does not.
+        zope.testing. runalldoctests.py does not. Perhaps the easiest way to run the
+        tests is::
+        
+        $ python setup.py test
+        
         
         Support
         -------
@@ -131,9 +142,24 @@ Description: Shapely
         http://trac.gispython.org/projects/PCL/wiki/CommunityList
         
         
+        Credits
+        -------
+        
+        Sean Gillies (Pleiades)
+        Howard Butler (Hobu, Inc.)
+        Kai Lautaportti (Hexagon IT)
+        Frederic Junod (Camptocamp SA)
+        Eric Lemoine (Camptocamp SA)
+        Justin Bronn (GeoDjango) for ctypes inspiration
+        Artem Pavlenko (Mapnik) for help with GEOS DLLs
+        
+        Some of this work was supported by a grant (Pleiades) from the U.S. National
+        Endowment for the Humanities (http://www.neh.gov).
+        
+        
 Keywords: geometry topology
 Platform: UNKNOWN
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License

EGG-INFO/SOURCES.txt

@@ -4,6 +4,7 @@ HISTORY.txt
 LICENSE.txt
 README.txt
 setup.py
+setup_windows.py
 Shapely.egg-info/PKG-INFO
 Shapely.egg-info/SOURCES.txt
 Shapely.egg-info/dependency_links.txt

shapely/geometry/base.py

@@ -5,7 +5,7 @@ Base geometry class and utilities.
 from ctypes import string_at, byref, c_int, c_size_t, c_char_p, c_double
 import sys
 
-from shapely.geos import lgeos
+from shapely.geos import lgeos, free, allocated_c_char_p
 from shapely.predicates import BinaryPredicate, UnaryPredicate
 from shapely.topology import BinaryTopologicalOp, UnaryTopologicalOp
 
@@ -22,6 +22,8 @@ GEOMETRY_TYPES = [
     ]
 
 def geometry_type_name(g):
+    if g is None:
+        raise ValueError, "Null geometry has no type"
     return GEOMETRY_TYPES[lgeos.GEOSGeomTypeId(g)]
 
 # Abstract geometry factory for use with topological methods below
@@ -156,23 +158,42 @@ class GeometrySequence(object):
                 max = l
 
 
+def exceptNull(func):
+    """Decorator which helps avoid GEOS operations on null pointers."""
+    def wrapper(*args, **kwargs):
+        # self is the first arg
+        if args[0]._geom is None:
+            raise ValueError, "Null geometry supports no operations"
+        return func(*args, **kwargs)
+    return wrapper
+
+def exceptEitherNull(func):
+    """Decorator which avoids GEOS operations on one or more null pointers."""
+    def wrapper(*args, **kwargs):
+        # self is the first arg
+        if args[0]._geom is None or args[1]._geom is None:
+            raise ValueError, "Null geometry supports no operations"
+        return func(*args, **kwargs)
+    return wrapper
+
+
 class BaseGeometry(object):
     
     """Provides GEOS spatial predicates and topological operations.
     """
 
-    _geom = None
+    __geom = None # See _geom property below
     _ctypes_data = None
     _ndim = None
     _crs = None
     _owned = False
 
     def __init__(self):
-        self._geom = lgeos.GEOSGeomFromWKT(c_char_p('GEOMETRYCOLLECTION EMPTY'))
+        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()
@@ -189,11 +210,20 @@ 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))
                         )
 
+    # _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)
+
     # Array and ctypes interfaces
 
     @property
@@ -222,6 +252,7 @@ class BaseGeometry(object):
         """Provide the Numpy array protocol."""
         raise NotImplementedError
 
+    @exceptNull
     def get_coords(self):
         return CoordinateSequence(self)
 
@@ -243,19 +274,34 @@ class BaseGeometry(object):
 
     # Type of geometry and its representations
 
+    @exceptNull
     def geometryType(self):
         """Returns a string representing the geometry type, e.g. 'Polygon'."""
         return geometry_type_name(self._geom)
 
+    @exceptNull
     def to_wkb(self):
         """Returns a WKB byte string representation of the geometry."""
+        func = lgeos.GEOSGeomToWKB_buf
         size = c_int()
-        bytes = lgeos.GEOSGeomToWKB_buf(self._geom, byref(size))
-        return string_at(bytes, size.value)
-
+        def errcheck(result, func, argtuple):
+            retval = string_at(result, size.value)[:]
+            free(result)
+            return retval
+        func.errcheck = errcheck
+        return func(self._geom, byref(size))
+
+    @exceptNull
     def to_wkt(self):
         """Returns a WKT string representation of the geometry."""
-        return string_at(lgeos.GEOSGeomToWKT(self._geom))
+        func = lgeos.GEOSGeomToWKT
+        def errcheck(result, func, argtuple):
+            retval = result.value
+            free(result)
+            return retval
+        func.restype = allocated_c_char_p
+        func.errcheck = errcheck
+        return lgeos.GEOSGeomToWKT(self._geom)
 
     geom_type = property(geometryType)
     wkt = property(to_wkt)
@@ -264,17 +310,20 @@ class BaseGeometry(object):
     # Basic geometry properties
 
     @property
+    @exceptNull
     def area(self):
         a = c_double()
         retval =  lgeos.GEOSArea(self._geom, byref(a))
         return a.value
 
     @property
+    @exceptNull
     def length(self):
         len = c_double()
         retval =  lgeos.GEOSLength(self._geom, byref(len))
         return len.value
 
+    @exceptEitherNull
     def distance(self, other):
         d = c_double()
         retval =  lgeos.GEOSDistance(self._geom, other._geom, byref(d))
@@ -295,15 +344,22 @@ class BaseGeometry(object):
     centroid = UnaryTopologicalOp(lgeos.GEOSGetCentroid, geom_factory)
 
     # Buffer has a unique distance argument, so not a descriptor
+    @exceptNull
     def buffer(self, distance, quadsegs=16):
         return geom_factory(
             lgeos.GEOSBuffer(self._geom, c_double(distance), c_int(quadsegs))
             )
 
     # Relate has a unique string return value
+    @exceptNull
     def relate(self, other):
         func = lgeos.GEOSRelate
-        func.restype = c_char_p
+        def errcheck(result, func, argtuple):
+            retval = result.value
+            free(result)
+            return retval
+        func.restype = allocated_c_char_p
+        func.errcheck = errcheck
         return lgeos.GEOSRelate(self._geom, other._geom)
 
     # Binary predicates
@@ -331,6 +387,7 @@ class BaseGeometry(object):
     has_z = UnaryPredicate(lgeos.GEOSHasZ)
 
     @property
+    @exceptNull
     def bounds(self):
         env = self.envelope
         if env.geom_type != 'Polygon':

shapely/geometry/linestring.py

@@ -6,7 +6,7 @@ from ctypes import byref, c_double, c_int, cast, POINTER, pointer
 from ctypes import ArgumentError
 
 from shapely.geos import lgeos
-from shapely.geometry.base import BaseGeometry
+from shapely.geometry.base import BaseGeometry, exceptNull
 
 
 def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
@@ -86,7 +86,7 @@ def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
     if update_geom is not None:
         return None
     else:
-        return (lgeos.GEOSGeom_createLineString(cs), n)
+        return lgeos.GEOSGeom_createLineString(cs), n
 
 def update_linestring_from_py(geom, ob):
     geos_linestring_from_py(ob, geom._geom, geom._ndim)
@@ -118,7 +118,9 @@ class LineString(BaseGeometry):
         Each result in a line string from (0.0, 0.0) to (1.0, 2.0).
         """
         BaseGeometry.__init__(self)
+        self._init_geom(coordinates)
 
+    def _init_geom(self, coordinates):
         if coordinates is None:
             # allow creation of null lines, to support unpickling
             pass
@@ -133,6 +135,7 @@ class LineString(BaseGeometry):
             }
 
     @property
+    @exceptNull
     def ctypes(self):
         if not self._ctypes_data:
             cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
@@ -164,6 +167,8 @@ class LineString(BaseGeometry):
     # Coordinate access
 
     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)
@@ -176,14 +181,12 @@ class LineStringAdapter(LineString):
     """
     
     context = None
+    __geom = None
+    _owned = False
 
     def __init__(self, context):
         self.context = context
 
-    # Override base class __del__
-    def __del__(self):
-        pass
-
     @property
     def _ndim(self):
         try:
@@ -199,7 +202,10 @@ class LineStringAdapter(LineString):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        return geos_linestring_from_py(self.context)[0]       
+        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):

shapely/geometry/multilinestring.py

@@ -5,7 +5,7 @@ Multi-part collection of linestrings.
 from ctypes import byref, c_double, c_int, c_void_p, cast, POINTER, pointer
 
 from shapely.geos import lgeos
-from shapely.geometry.base import BaseGeometry, GeometrySequence
+from shapely.geometry.base import BaseGeometry, GeometrySequence, exceptNull
 from shapely.geometry.linestring import LineString, geos_linestring_from_py
 
 
@@ -102,6 +102,7 @@ class MultiLineString(BaseGeometry):
         "Multi-part geometries do not provide a coordinate sequence"
 
     @property
+    @exceptNull
     def geoms(self):
         return GeometrySequence(self, LineString)
 
@@ -113,14 +114,12 @@ class MultiLineStringAdapter(MultiLineString):
     """
     
     context = None
+    __geom = None
+    _owned = False
 
     def __init__(self, context):
         self.context = context
 
-    # Override base class __del__
-    def __del__(self):
-        pass
-
     @property
     def _ndim(self):
         try:
@@ -136,7 +135,10 @@ class MultiLineStringAdapter(MultiLineString):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        return geos_multilinestring_from_py(self.context)[0]       
+        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/geometry/multipoint.py

@@ -5,7 +5,7 @@ Multiple points.
 from ctypes import byref, c_double, c_int, c_void_p, cast, POINTER, pointer
 
 from shapely.geos import lgeos
-from shapely.geometry.base import BaseGeometry, GeometrySequence
+from shapely.geometry.base import BaseGeometry, GeometrySequence, exceptNull
 from shapely.geometry.point import Point, geos_point_from_py
 
 
@@ -44,7 +44,7 @@ def geos_multipoint_from_py(ob):
             geom, ndims = geos_point_from_py(coords)
             subs[i] = cast(geom, c_void_p)
             
-    return (lgeos.GEOSGeom_createCollection(4, subs, m), n)
+    return lgeos.GEOSGeom_createCollection(4, subs, m), n
 
 
 class MultiPoint(BaseGeometry):
@@ -81,6 +81,7 @@ class MultiPoint(BaseGeometry):
 
 
     @property
+    @exceptNull
     def __geo_interface__(self):
         return {
             'type': 'MultiPoint',
@@ -88,6 +89,7 @@ class MultiPoint(BaseGeometry):
             }
 
     @property
+    @exceptNull
     def ctypes(self):
         if not self._ctypes_data:
             temp = c_double()
@@ -108,6 +110,7 @@ class MultiPoint(BaseGeometry):
             self._ctypes_data = data
         return self._ctypes_data
 
+    @exceptNull
     def array_interface(self):
         """Provide the Numpy array protocol."""
         ai = self.array_interface_base
@@ -121,6 +124,7 @@ class MultiPoint(BaseGeometry):
         "Multipart geometries do not themselves provide coordinate sequences"
 
     @property
+    @exceptNull
     def geoms(self):
         return GeometrySequence(self, Point)
         
@@ -132,14 +136,12 @@ class MultiPointAdapter(MultiPoint):
     """
     
     context = None
+    __geom = None
+    _owned = False
 
     def __init__(self, context):
         self.context = context
 
-    # Override base class __del__
-    def __del__(self):
-        pass
-
     @property
     def _ndim(self):
         try:
@@ -155,7 +157,10 @@ class MultiPointAdapter(MultiPoint):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        return geos_multipoint_from_py(self.context)[0]       
+        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/geometry/multipolygon.py

@@ -5,7 +5,7 @@ Multi-part collection of polygons.
 from ctypes import byref, c_double, c_int, c_void_p, cast, POINTER, pointer
 
 from shapely.geos import lgeos
-from shapely.geometry.base import BaseGeometry, GeometrySequence
+from shapely.geometry.base import BaseGeometry, GeometrySequence, exceptNull
 from shapely.geometry.polygon import Polygon, geos_polygon_from_py
 
 
@@ -88,6 +88,7 @@ class MultiPolygon(BaseGeometry):
         "Multi-part geometries do not provide a coordinate sequence"
 
     @property
+    @exceptNull
     def geoms(self):
         return GeometrySequence(self, Polygon)
 
@@ -99,14 +100,12 @@ class MultiPolygonAdapter(MultiPolygon):
     """
     
     context = None
+    __geom = None
+    _owned = False
 
     def __init__(self, context):
         self.context = context
 
-    # Override base class __del__
-    def __del__(self):
-        pass
-
     @property
     def _ndim(self):
         try:
@@ -122,7 +121,10 @@ class MultiPolygonAdapter(MultiPolygon):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        return geos_multipolygon_from_py(self.context)[0]       
+        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/geometry/point.py

@@ -9,6 +9,7 @@ from ctypes import cast, POINTER
 
 from shapely.geos import lgeos, DimensionError
 from shapely.geometry.base import BaseGeometry, CoordinateSequence
+from shapely.geometry.base import exceptNull
 
 
 def geos_point_from_py(ob, update_geom=None, update_ndim=0):
@@ -33,8 +34,12 @@ def geos_point_from_py(ob, update_geom=None, update_ndim=0):
             dz = c_double(cp[2])
             ndim = 3
     except AttributeError:
-        # Fall back on list
-        coords = ob
+        # Fall back on the case of Python sequence data
+        # Accept either (x, y) or [(x, y)]
+        if type(ob[0]) == type(tuple()):
+            coords = ob[0]
+        else:
+            coords = ob
         n = len(coords)
         dx = c_double(coords[0])
         dy = c_double(coords[1])
@@ -60,7 +65,7 @@ def geos_point_from_py(ob, update_geom=None, update_ndim=0):
     if update_geom:
         return None
     else:
-        return (lgeos.GEOSGeom_createPoint(cs), n)
+        return lgeos.GEOSGeom_createPoint(cs), n
 
 def update_point_from_py(geom, ob):
     geos_point_from_py(ob, geom._geom, geom._ndim)
@@ -102,7 +107,9 @@ class Point(BaseGeometry):
             Easting, northing, and elevation.
         """
         BaseGeometry.__init__(self)
+        self._init_geom(*args)
 
+    def _init_geom(self, *args):
         if len(args) == 0:
             # allow creation of null points, to support unpickling
             pass
@@ -115,6 +122,7 @@ class Point(BaseGeometry):
     # Coordinate getters and setters
 
     @property
+    @exceptNull
     def x(self):
         """Return x coordinate."""
         cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
@@ -123,6 +131,7 @@ class Point(BaseGeometry):
         return d.value
     
     @property
+    @exceptNull
     def y(self):
         """Return y coordinate."""
         cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
@@ -131,6 +140,7 @@ class Point(BaseGeometry):
         return d.value
     
     @property
+    @exceptNull
     def z(self):
         """Return z coordinate."""
         if self._ndim != 3:
@@ -141,6 +151,7 @@ class Point(BaseGeometry):
         return d.value
     
     @property
+    @exceptNull
     def __geo_interface__(self):
         return {
             'type': 'Point',
@@ -148,6 +159,7 @@ class Point(BaseGeometry):
             }
 
     @property
+    @exceptNull
     def ctypes(self):
         if not self._ctypes_data:
             array_type = c_double * self._ndim
@@ -167,6 +179,7 @@ class Point(BaseGeometry):
     __array_interface__ = property(array_interface)
 
     @property
+    @exceptNull
     def bounds(self):
         cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
         x = c_double()
@@ -178,7 +191,10 @@ class Point(BaseGeometry):
     # Coordinate access
 
     def set_coords(self, coordinates):
-        update_point_from_py(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)
 
@@ -189,14 +205,12 @@ class PointAdapter(Point):
     """
 
     context = None
+    __geom = None
+    _owned = False
 
     def __init__(self, context):
         self.context = context
 
-    # Override base class __del__
-    def __del__(self):
-        pass
-
     @property
     def _ndim(self):
         try:
@@ -212,7 +226,10 @@ class PointAdapter(Point):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        return geos_point_from_py(self.context)[0]       
+        if self.__geom is not None:
+            lgeos.GEOSGeom_destroy(self.__geom)
+        self.__geom, n = geos_point_from_py(self.context)
+        return self.__geom
 
     # TODO: reimplement x, y, z properties without calling invoking _geom
 

shapely/geometry/polygon.py

@@ -5,7 +5,7 @@ Polygons and their linear ring components.
 from ctypes import byref, c_double, c_int, c_void_p, cast, POINTER, pointer
 
 from shapely.geos import lgeos
-from shapely.geometry.base import BaseGeometry
+from shapely.geometry.base import BaseGeometry, exceptNull
 from shapely.geometry.linestring import LineString, LineStringAdapter
 
 
@@ -129,7 +129,7 @@ def geos_linearring_from_py(ob, update_geom=None, update_ndim=0):
     if update_geom is not None:
         return None
     else:
-        return (lgeos.GEOSGeom_createLinearRing(cs), n)
+        return lgeos.GEOSGeom_createLinearRing(cs), n
 
 def update_linearring_from_py(geom, ob):
     geos_linearring_from_py(ob, geom._geom, geom._ndim)
@@ -141,6 +141,8 @@ class LinearRing(LineString):
     """
 
     _ndim = 2
+    __geom = None
+    _owned = False
 
     def __init__(self, coordinates=None):
         """Initialize.
@@ -162,7 +164,9 @@ class LinearRing(LineString):
         Produces a 1x1 square.
         """
         BaseGeometry.__init__(self)
+        self._init_geom(coordinates)
 
+    def _init_geom(self, coordinates):
         if coordinates is None:
             # allow creation of null lines, to support unpickling
             pass
@@ -179,6 +183,8 @@ class LinearRing(LineString):
     # Coordinate access
 
     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)
@@ -186,10 +192,17 @@ class LinearRing(LineString):
 
 class LinearRingAdapter(LineStringAdapter):
 
+    context = None
+    __geom = None
+    _owned = False
+
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        return geos_linearring_from_py(self.context)[0]       
+        if self.__geom is not None:
+            lgeos.GEOSGeom_destroy(self.__geom)
+        self.__geom, n = geos_linearring_from_py(self.context)
+        return self.__geom
 
     @property
     def __geo_interface__(self):
@@ -260,9 +273,6 @@ class InteriorRingSequence(object):
 def geos_polygon_from_py(shell, holes=None):
     if shell is not None:
         geos_shell, ndims = geos_linearring_from_py(shell)
-        ## Polygon geometry takes ownership of the ring
-        #self._exterior._owned = True
-
         if holes:
             ob = holes
             L = len(ob)
@@ -302,6 +312,8 @@ class Polygon(BaseGeometry):
     _exterior = None
     _interiors = []
     _ndim = 2
+    __geom = None
+    _owned = False
 
     def __init__(self, shell=None, holes=None):
         """Initialize.
@@ -324,6 +336,7 @@ class Polygon(BaseGeometry):
             self._geom, self._ndims = geos_polygon_from_py(shell, holes)
 
     @property
+    @exceptNull
     def exterior(self):
         if self._exterior is None:
             # A polygon created from the abstract factory will have a null
@@ -335,6 +348,7 @@ class Polygon(BaseGeometry):
         return self._exterior
 
     @property
+    @exceptNull
     def interiors(self):
         return InteriorRingSequence(self)
 
@@ -372,15 +386,13 @@ class PolygonAdapter(Polygon):
     """
     
     context = None
+    __geom = None
+    _owned = False
 
     def __init__(self, shell, holes=None):
         self.shell = shell
         self.holes = holes
 
-    # Override base class __del__
-    def __del__(self):
-        pass
-
     @property
     def _ndim(self):
         try:
@@ -396,7 +408,10 @@ class PolygonAdapter(Polygon):
     @property
     def _geom(self):
         """Keeps the GEOS geometry in synch with the context."""
-        return geos_polygon_from_py(self.shell, self.holes)[0]       
+        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/geos.py

@@ -3,21 +3,25 @@ Exports the libgeos_c shared lib, GEOS-specific exceptions, and utilities.
 """
 
 import atexit
-from ctypes import CDLL, CFUNCTYPE, c_char_p
+from ctypes import cdll, CDLL, CFUNCTYPE, c_char_p
 from ctypes.util import find_library
+import os
 import sys
 
+import shapely
+
 if sys.platform == 'win32':
     try:
-        lgeos = CDLL('libgeos_c.dll')
+        geospath = os.path.abspath(
+            shapely.__file__ + "../../../../../DLLs/geos_c.dll"
+            )
+        lgeos = CDLL(geospath)
     except (ImportError, WindowsError):
-        # Try GEOS DLL from the Windows PostGIS installer for
-        # PostgreSQL 8.2 before failing
-        lgeos = CDLL('libgeos_c-1.dll')
-    except:
         raise
+    free = cdll.msvcrt.free
 elif sys.platform == 'darwin':
     lgeos = CDLL(find_library('geos_c'))
+    free = CDLL(find_library('libc')).free
 else:
     # Try the major versioned name first, falling back on the unversioned name.
     try:
@@ -26,6 +30,12 @@ else:
         lgeos = CDLL('libgeos_c.so')
     except:
         raise
+    free = CDLL('libc.so.6').free
+
+
+class allocated_c_char_p(c_char_p):
+    pass
+
 
 # Exceptions
 

shapely/iterops.py

@@ -2,7 +2,7 @@
 """
 
 from ctypes import c_char_p, c_size_t
-from shapely.geos import lgeos
+from shapely.geos import lgeos, free
 
 
 def geos_from_geometry(geom):
@@ -28,20 +28,22 @@ class BinaryPredicateIterator(object):
         return self
 
     def __call__(self, geom, iterator, value=True):
-        geos_geom = geos_from_geometry(geom)
+        if geom._geom is None:
+            raise ValueError, "Null geometry supports no operations"
         for item in iterator:
             try:
-                geom, ob = item
+                this_geom, ob = item
             except TypeError:
-                geom = item
-                ob = geom
-            retval = self.fn(geos_geom, geos_from_geometry(geom))
+                this_geom = item
+                ob = this_geom
+            if this_geom._geom is None:
+                raise ValueError, "Null geometry supports no operations"
+            retval = self.fn(geom._geom, this_geom._geom)
             if retval == 2:
                 raise PredicateError, "Failed to evaluate %s" % repr(self.fn)
             elif bool(retval) == value:
                 yield ob
 
-
 # utilities
 disjoint = BinaryPredicateIterator(lgeos.GEOSDisjoint)
 touches = BinaryPredicateIterator(lgeos.GEOSTouches)

shapely/predicates.py

@@ -16,16 +16,20 @@ class BinaryPredicate(object):
 
     def __init__(self, fn):
         self.fn = fn
+        def errcheck(result, func, argtuple):
+            if result == 2:
+                raise PredicateError, "Failed to evaluate %s" % repr(self.fn)
+            return result
+        self.fn.errcheck = errcheck
 
     def __get__(self, obj, objtype=None):
         self.context = obj
         return self
 
     def __call__(self, other):
-        retval = self.fn(self.context._geom, other._geom)
-        if retval == 2:
-            raise PredicateError, "Failed to evaluate %s" % repr(self.fn)
-        return bool(retval)
+        if self.context._geom is None or other._geom is None:
+            raise ValueError, "Null geometry supports no operations"
+        return bool(self.fn(self.context._geom, other._geom))
 
 
 # A data descriptor
@@ -38,12 +42,16 @@ class UnaryPredicate(object):
 
     def __init__(self, fn):
         self.fn = fn
+        def errcheck(result, func, argtuple):
+            if result == 2:
+                raise PredicateError, "Failed to evaluate %s" % repr(self.fn)
+            return result
+        self.fn.errcheck = errcheck
 
     def __get__(self, obj, objtype=None):
-        retval = self.fn(obj._geom)
-        if retval == 2:
-            raise PredicateError, "Failed to evaluate %s" % repr(self.fn)
-        return bool(retval)
+        if obj._geom is None:
+            raise ValueError, "Null geometry supports no operations"
+        return bool(self.fn(obj._geom))
     
     def __set__(self, obj, value=None):
         raise AttributeError, "Attribute is read-only"

shapely/topology.py

@@ -26,6 +26,8 @@ class BinaryTopologicalOp(object):
         return self
 
     def __call__(self, other):
+        if self.context._geom is None or other._geom is None:
+            raise ValueError, "Null geometry supports no operations"
         product = self.fn(self.context._geom, other._geom)
         if not product:
             # Check validity of geometries
@@ -55,6 +57,8 @@ class UnaryTopologicalOp(object):
         self.factory = factory
 
     def __get__(self, obj, objtype=None):
+        if obj._geom is None:
+            raise ValueError, "Null geometry supports no operations"
         return self.factory(self.fn(obj._geom))
     
     def __set__(self, obj, value=None):

shapely/wkb.py

@@ -4,7 +4,7 @@ Load/dump geometries using the well-known binary (WKB) format.
 
 from ctypes import byref, c_int, c_size_t, c_char_p, string_at
 
-from shapely.geos import lgeos, ReadingError
+from shapely.geos import lgeos, free, ReadingError
 from shapely.geometry.base import geom_factory
 
 
@@ -25,9 +25,14 @@ def load(fp):
 
 def dumps(ob):
     """Dump a WKB representation of a geometry to a byte string."""
+    func = lgeos.GEOSGeomToWKB_buf
     size = c_int()
-    bytes = lgeos.GEOSGeomToWKB_buf(ob._geom, byref(size))
-    return string_at(bytes, size.value)
+    def errcheck(result, func, argtuple):
+        retval = string_at(result, size.value)[:]
+        free(result)
+        return retval
+    func.errcheck = errcheck
+    return func(ob._geom, byref(size))
 
 def dump(ob, fp):
     """Dump a geometry to an open file."""

shapely/wkt.py

@@ -4,7 +4,7 @@ Load/dump geometries using the well-known text (WKT) format.
 
 from ctypes import byref, c_int, c_size_t, c_char_p, string_at
 
-from shapely.geos import lgeos, ReadingError
+from shapely.geos import lgeos, free, allocated_c_char_p, ReadingError
 from shapely.geometry.base import geom_factory
 
 
@@ -25,7 +25,14 @@ def load(fp):
 
 def dumps(ob):
     """Dump a WKB representation of a geometry to a byte string."""
-    return string_at(lgeos.GEOSGeomToWKT(ob._geom))
+    func = lgeos.GEOSGeomToWKT
+    def errcheck(result, func, argtuple):
+        retval = result.value
+        free(result)
+        return retval
+    func.restype = allocated_c_char_p
+    func.errcheck = errcheck
+    return lgeos.GEOSGeomToWKT(ob._geom)
 
 def dump(ob, fp):
     """Dump a geometry to an open file."""