shapely 1.0__py2.4.egg → 1.0a7__py2.4.egg

EGG-INFO/PKG-INFO

@@ -1,16 +1,16 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.0
+Version: 1.0a7
 Summary: Geospatial geometries, predicates, and operations
-Home-page: http://trac.gispython.org/projects/PCL/wiki/Shapely
+Home-page: http://trac.gispython.org/projects/PCL/wiki/ShapeLy
 Author: Sean Gillies
 Author-email: sgillies@frii.com
-License: BSD
+License: LGPL
 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
+        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
         coordinate and reference systems. Projection responsibility is left to specific
         applications. For more information, see:
         
@@ -20,22 +20,21 @@ 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/.)
         
+        .. _wiki: http://trac.gispython.org/projects/PCL/wiki/Shapely
+        .. _manual: http://trac.gispython.org/projects/PCL/wiki/ShapelyManual
         
         Dependencies
         ------------
         
-        * libgeos_c (2.2.3 or 3.0.0+)
+        * libgeos_c (2.2.3, also reported to work with 3.0 after small modifications.)
         * Python ctypes_ (standard in Python 2.5+)
         
         .. _ctypes: http://pypi.python.org/pypi/ctypes/
         
-        
         Installation
         ------------
         
-        Windows users should use the executable installer, which contains the required
-        GEOS DLL. Other users should acquire libgeos_c by any means, make sure that it
-        is on the system library path, and install from the Python package index::
+        Shapely can be installed from the Python package index::
         
         $ sudo easy_install Shapely
         
@@ -43,29 +42,26 @@ Description: Shapely
         
         $ sudo python setup.py install
         
-        or by using the development buildout on Linux, which also provides libgeos_c::
+        or by using the development buildout, 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
         -----
         
-        To buffer a point::
+        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 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.
-        
+        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.
         
         Numpy integration
         -----------------
@@ -87,7 +83,6 @@ Description: Shapely
         >>> line.wkt
         'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
         
-        
         Python Geo Interface
         --------------------
         
@@ -115,7 +110,6 @@ Description: Shapely
         See http://trac.gispython.org/projects/PCL/wiki/PythonGeoInterface for more
         details on the interface.
         
-        
         Testing
         -------
         
@@ -125,49 +119,15 @@ Description: Shapely
         $ python point.py
         
         There are also two test runners under tests/. test_doctests.py requires
-        zope.testing. runalldoctests.py does not. Perhaps the easiest way to run the
-        tests is::
-        
-        $ python setup.py test
-        
-        
-        Support
-        -------
-        
-        For current information about this project, see the wiki_.
-        
-        .. _wiki: http://trac.gispython.org/projects/PCL/wiki/Shapely
-        .. _manual: http://gispython.org/shapely/manual.html
-        
-        If you have questions, please consider joining our community list:
-        
-        http://trac.gispython.org/projects/PCL/wiki/CommunityList
-        
-        
-        Credits
-        -------
-        
-        * Sean Gillies (Pleiades)
-        * Howard Butler (Hobu, Inc.)
-        * Kai Lautaportti (Hexagon IT)
-        * Fr |eaigue| d |eaigue| ric Junod (Camptocamp SA)
-        * Eric Lemoine (Camptocamp SA)
-        * Justin Bronn (GeoDjango) for ctypes inspiration
-        * Artem Pavlenko (Mapnik) for help with GEOS DLLs
-        
-        .. |eaigue| unicode:: U+00E9
-        :trim:
-        
-        Major portions of this work were supported by a grant (to Pleiades) from the
-        U.S.  National Endowment for the Humanities (http://www.neh.gov).
+        zope.testing. runalldoctests.py does not.
         
         
 Keywords: geometry topology
 Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: BSD License
+Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: GIS

EGG-INFO/SOURCES.txt

@@ -1,10 +1,6 @@
-CHANGES.txt
 CREDITS.txt
-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
@@ -12,8 +8,6 @@ Shapely.egg-info/requires.txt
 Shapely.egg-info/top_level.txt
 examples/geoms.py
 examples/world.py
-manual/manual.txt
-manual/style.css
 shapely/__init__.py
 shapely/geos.py
 shapely/iterops.py
@@ -45,8 +39,7 @@ tests/Point.txt
 tests/Polygon.txt
 tests/Predicates.txt
 tests/__init__.py
-tests/binascii_hex.txt
-tests/invalid_intersection.txt
+tests/runalldoctests.py
 tests/rungrind.dist
+tests/runtests.dist
 tests/test_doctests.py
-tests/valgrind-python.supp

shapely/geometry/base.py

@@ -3,36 +3,17 @@ 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, free, allocated_c_char_p
+from shapely.geos import lgeos
 from shapely.predicates import BinaryPredicate, UnaryPredicate
 from shapely.topology import BinaryTopologicalOp, UnaryTopologicalOp
 
 
-GEOMETRY_TYPES = [
-    'Point',
-	'LineString',
-	'LinearRing',
-	'Polygon',
-	'MultiPoint',
-	'MultiLineString',
-	'MultiPolygon',
-	'GeometryCollection'
-    ]
-
-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
 
 def geom_factory(g):
-    if not g:
-        raise ValueError, "No Shapely geometry can be created from this null value"
     ob = BaseGeometry()
-    geom_type = geometry_type_name(g)
+    geom_type = string_at(lgeos.GEOSGeomType(g))
     # TODO: check cost of dynamic import by profiling
     mod = __import__(
         'shapely.geometry', 
@@ -158,42 +139,23 @@ 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 # See _geom property below
+    _geom = None
     _ctypes_data = None
     _ndim = None
     _crs = None
     _owned = False
 
     def __init__(self):
-        self.__geom = None
+        self._geom = lgeos.GEOSGeomFromWKT(c_char_p('GEOMETRYCOLLECTION EMPTY'))
 
     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,20 +172,11 @@ 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
@@ -233,26 +186,11 @@ class BaseGeometry(object):
         To be overridden by extension classes."""
         raise NotImplementedError
 
-    @property
-    def array_interface_base(self):
-        if sys.byteorder == 'little':
-            typestr = '<f8'
-        elif sys.byteorder == 'big':
-            typestr = '>f8'
-        else:
-            raise ValueError, "Unsupported byteorder: neither little nor big-endian"
-        return {
-            'version': 3,
-            'typestr': typestr,
-            'data': self.ctypes,
-            }
-
     @property
     def __array_interface__(self):
         """Provide the Numpy array protocol."""
         raise NotImplementedError
 
-    @exceptNull
     def get_coords(self):
         return CoordinateSequence(self)
 
@@ -274,34 +212,19 @@ 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)
+        return string_at(lgeos.GEOSGeomType(self._geom))
 
-    @exceptNull
     def to_wkb(self):
         """Returns a WKB byte string representation of the geometry."""
-        func = lgeos.GEOSGeomToWKB_buf
         size = c_int()
-        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
+        bytes = lgeos.GEOSGeomToWKB_buf(self._geom, byref(size))
+        return string_at(bytes, size.value)
+
     def to_wkt(self):
         """Returns a WKT string representation of the geometry."""
-        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)
+        return string_at(lgeos.GEOSGeomToWKT(self._geom))
 
     geom_type = property(geometryType)
     wkt = property(to_wkt)
@@ -310,20 +233,17 @@ 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))
@@ -344,22 +264,15 @@ 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
-        def errcheck(result, func, argtuple):
-            retval = result.value
-            free(result)
-            return retval
-        func.restype = allocated_c_char_p
-        func.errcheck = errcheck
+        func.restype = c_char_p
         return lgeos.GEOSRelate(self._geom, other._geom)
 
     # Binary predicates
@@ -387,7 +300,6 @@ 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, exceptNull
+from shapely.geometry.base import BaseGeometry
 
 
 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,9 +118,7 @@ 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
@@ -135,7 +133,6 @@ class LineString(BaseGeometry):
             }
 
     @property
-    @exceptNull
     def ctypes(self):
         if not self._ctypes_data:
             cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
@@ -157,18 +154,19 @@ class LineString(BaseGeometry):
             self._ctypes_data = data
         return self._ctypes_data
 
-    def array_interface(self):
+    @property
+    def __array_interface__(self):
         """Provide the Numpy array protocol."""
-        ai = self.array_interface_base
-        ai.update({'shape': (len(self.coords), self._ndim)})
-        return ai
-    __array_interface__ = property(array_interface)
+        return {
+            'version': 3,
+            'shape': (len(self.coords), self._ndim),
+            'typestr': '<f8',
+            'data': self.ctypes,
+            }
 
     # 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)
@@ -181,12 +179,14 @@ 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:
@@ -202,10 +202,7 @@ 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
+        return geos_linestring_from_py(self.context)[0]       
 
     @property
     def __array_interface__(self):
@@ -213,7 +210,12 @@ class LineStringAdapter(LineString):
         try:
             return self.context.__array_interface__
         except AttributeError:
-            return self.array_interface()
+            return {
+                'version': 3,
+                'shape': (self._ndim,),
+                'typestr': '<f8',
+                'data': self.ctypes,
+                }
 
     coords = property(BaseGeometry.get_coords)
 

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, exceptNull
+from shapely.geometry.base import BaseGeometry, GeometrySequence
 from shapely.geometry.linestring import LineString, geos_linestring_from_py
 
 
@@ -102,7 +102,6 @@ class MultiLineString(BaseGeometry):
         "Multi-part geometries do not provide a coordinate sequence"
 
     @property
-    @exceptNull
     def geoms(self):
         return GeometrySequence(self, LineString)
 
@@ -114,12 +113,14 @@ 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:
@@ -135,10 +136,7 @@ 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
+        return geos_multilinestring_from_py(self.context)[0]       
 
 
 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, exceptNull
+from shapely.geometry.base import BaseGeometry, GeometrySequence
 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,7 +81,6 @@ class MultiPoint(BaseGeometry):
 
 
     @property
-    @exceptNull
     def __geo_interface__(self):
         return {
             'type': 'MultiPoint',
@@ -89,7 +88,6 @@ class MultiPoint(BaseGeometry):
             }
 
     @property
-    @exceptNull
     def ctypes(self):
         if not self._ctypes_data:
             temp = c_double()
@@ -110,13 +108,15 @@ class MultiPoint(BaseGeometry):
             self._ctypes_data = data
         return self._ctypes_data
 
-    @exceptNull
-    def array_interface(self):
+    @property
+    def __array_interface__(self):
         """Provide the Numpy array protocol."""
-        ai = self.array_interface_base
-        ai.update({'shape': (len(self.geoms), self._ndim)})
-        return ai
-    __array_interface__ = property(array_interface)
+        return {
+            'version': 3,
+            'shape': (len(self.geoms), self._ndim),
+            'typestr': '<f8',
+            'data': self.ctypes,
+            }
 
     @property
     def coords(self):
@@ -124,7 +124,6 @@ class MultiPoint(BaseGeometry):
         "Multipart geometries do not themselves provide coordinate sequences"
 
     @property
-    @exceptNull
     def geoms(self):
         return GeometrySequence(self, Point)
         
@@ -136,12 +135,14 @@ 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:
@@ -157,10 +158,7 @@ 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
+        return geos_multipoint_from_py(self.context)[0]       
 
     @property
     def __array_interface__(self):
@@ -168,7 +166,12 @@ class MultiPointAdapter(MultiPoint):
         try:
             return self.context.__array_interface__
         except AttributeError:
-            return self.array_interface()
+            return {
+                'version': 3,
+                'shape': (self._ndim,),
+                'typestr': '<f8',
+                'data': self.ctypes,
+                }
 
 
 def asMultiPoint(context):

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, exceptNull
+from shapely.geometry.base import BaseGeometry, GeometrySequence
 from shapely.geometry.polygon import Polygon, geos_polygon_from_py
 
 
@@ -88,7 +88,6 @@ class MultiPolygon(BaseGeometry):
         "Multi-part geometries do not provide a coordinate sequence"
 
     @property
-    @exceptNull
     def geoms(self):
         return GeometrySequence(self, Polygon)
 
@@ -100,12 +99,14 @@ 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:
@@ -121,10 +122,7 @@ 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
+        return geos_multipolygon_from_py(self.context)[0]       
 
 
 def asMultiPolygon(context):

shapely/geometry/point.py

@@ -9,7 +9,6 @@ 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):
@@ -34,12 +33,8 @@ def geos_point_from_py(ob, update_geom=None, update_ndim=0):
             dz = c_double(cp[2])
             ndim = 3
     except AttributeError:
-        # 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
+        # Fall back on list
+        coords = ob
         n = len(coords)
         dx = c_double(coords[0])
         dy = c_double(coords[1])
@@ -65,7 +60,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)
@@ -107,9 +102,7 @@ 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
@@ -122,7 +115,6 @@ class Point(BaseGeometry):
     # Coordinate getters and setters
 
     @property
-    @exceptNull
     def x(self):
         """Return x coordinate."""
         cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
@@ -131,7 +123,6 @@ class Point(BaseGeometry):
         return d.value
     
     @property
-    @exceptNull
     def y(self):
         """Return y coordinate."""
         cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
@@ -140,7 +131,6 @@ class Point(BaseGeometry):
         return d.value
     
     @property
-    @exceptNull
     def z(self):
         """Return z coordinate."""
         if self._ndim != 3:
@@ -151,7 +141,6 @@ class Point(BaseGeometry):
         return d.value
     
     @property
-    @exceptNull
     def __geo_interface__(self):
         return {
             'type': 'Point',
@@ -159,7 +148,6 @@ class Point(BaseGeometry):
             }
 
     @property
-    @exceptNull
     def ctypes(self):
         if not self._ctypes_data:
             array_type = c_double * self._ndim
@@ -171,15 +159,17 @@ class Point(BaseGeometry):
             self._ctypes_data = array
         return self._ctypes_data
 
-    def array_interface(self):
+    @property
+    def __array_interface__(self):
         """Provide the Numpy array protocol."""
-        ai = self.array_interface_base
-        ai.update({'shape': (self._ndim,)})
-        return ai
-    __array_interface__ = property(array_interface)
+        return {
+            'version': 3,
+            'shape': (self._ndim,),
+            'typestr': '<f8',
+            'data': self.ctypes,
+            }
 
     @property
-    @exceptNull
     def bounds(self):
         cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
         x = c_double()
@@ -191,10 +181,7 @@ class Point(BaseGeometry):
     # Coordinate access
 
     def set_coords(self, coordinates):
-        if self._geom is None:
-            self._init_geom(coordinates)
-        else:
-            update_point_from_py(self, coordinates)
+        update_point_from_py(self, coordinates)
 
     coords = property(BaseGeometry.get_coords, set_coords)
 
@@ -205,12 +192,14 @@ 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:
@@ -226,10 +215,7 @@ class PointAdapter(Point):
     @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_point_from_py(self.context)
-        return self.__geom
+        return geos_point_from_py(self.context)[0]       
 
     # TODO: reimplement x, y, z properties without calling invoking _geom
 
@@ -239,11 +225,15 @@ class PointAdapter(Point):
         try:
             return self.context.__array_interface__
         except AttributeError:
-            return self.array_interface()
+            return {
+                'version': 3,
+                'shape': (self._ndim,),
+                'typestr': '<f8',
+                'data': self.ctypes,
+                }
 
     coords = property(BaseGeometry.get_coords)
 
-
 def asPoint(context):
     """Factory for PointAdapter instances."""
     return PointAdapter(context)

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, exceptNull
+from shapely.geometry.base import BaseGeometry
 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,8 +141,6 @@ class LinearRing(LineString):
     """
 
     _ndim = 2
-    __geom = None
-    _owned = False
 
     def __init__(self, coordinates=None):
         """Initialize.
@@ -164,9 +162,7 @@ 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
@@ -183,8 +179,6 @@ 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)
@@ -192,17 +186,10 @@ 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."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom, n = geos_linearring_from_py(self.context)
-        return self.__geom
+        return geos_linearring_from_py(self.context)[0]       
 
     @property
     def __geo_interface__(self):
@@ -273,6 +260,9 @@ 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)
@@ -312,8 +302,6 @@ class Polygon(BaseGeometry):
     _exterior = None
     _interiors = []
     _ndim = 2
-    __geom = None
-    _owned = False
 
     def __init__(self, shell=None, holes=None):
         """Initialize.
@@ -336,7 +324,6 @@ 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
@@ -348,7 +335,6 @@ class Polygon(BaseGeometry):
         return self._exterior
 
     @property
-    @exceptNull
     def interiors(self):
         return InteriorRingSequence(self)
 
@@ -386,13 +372,15 @@ 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:
@@ -408,13 +396,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
+        return geos_polygon_from_py(self.shell, self.holes)[0]       
 
 
-def asPolygon(shell, holes=None):
+def asPolygon(shell, holes):
     """Factory for PolygonAdapter instances."""
     return PolygonAdapter(shell, holes)
 

shapely/geos.py

@@ -3,31 +3,21 @@ Exports the libgeos_c shared lib, GEOS-specific exceptions, and utilities.
 """
 
 import atexit
-from ctypes import cdll, CDLL, CFUNCTYPE, c_char_p
+from ctypes import CDLL, CFUNCTYPE, c_char_p
 from ctypes.util import find_library
-import os
 import sys
 
-import shapely
-
 if sys.platform == 'win32':
     try:
-        local_dlls = os.path.abspath(os.__file__ + "../../../DLLs")
-        original_path = os.environ['PATH']
-        os.environ['PATH'] = "%s;%s" % (local_dlls, original_path)
-        lgeos = CDLL("geos.dll")
+        lgeos = CDLL('libgeos_c.dll')
     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
-    def free(m):
-        try:
-            cdll.msvcrt.free(m)
-        except WindowsError:
-            # XXX: See http://trac.gispython.org/projects/PCL/ticket/149
-            pass
-
 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:
@@ -36,12 +26,6 @@ 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, free
+from shapely.geos import lgeos
 
 
 def geos_from_geometry(geom):
@@ -28,22 +28,20 @@ class BinaryPredicateIterator(object):
         return self
 
     def __call__(self, geom, iterator, value=True):
-        if geom._geom is None:
-            raise ValueError, "Null geometry supports no operations"
+        geos_geom = geos_from_geometry(geom)
         for item in iterator:
             try:
-                this_geom, ob = item
+                geom, ob = item
             except TypeError:
-                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)
+                geom = item
+                ob = geom
+            retval = self.fn(geos_geom, geos_from_geometry(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/json.py

@@ -0,0 +1,47 @@
+"""
+Load/dump geometries using JSON.
+
+Includes a JSON-based abstract geometry factory.
+"""
+
+import geojson
+
+def json_factory(ob):
+    """Attempts to create a geometry from JSON.
+    
+    Else, returns the original data.
+    """
+    try:
+        coords = ob.get('coordinates', [])
+        geom_type = str(ob.get('type'))
+        mod = __import__(
+            'shapely.geometry', 
+            globals(), 
+            locals(), 
+            [geom_type],
+            )
+        geom_class = getattr(mod, geom_type)
+        return geom_class(*coords)
+    except (KeyError, TypeError):
+        raise 
+    return ob
+
+# Pickle-like convenience functions
+
+def loads(data):
+    """Load a geometry from a GeoJSON representation."""
+    return geojson.loads(data, json_factory)
+
+def load(fp):
+    """Load a geometry from an open file."""
+    data = fp.read()
+    return loads(data)
+
+def dumps(ob):
+    """Dump a GeoJSON representation of a geometry to a string."""
+    return geojson.dumps(ob)
+
+def dump(ob, fp):
+    """Dump a geometry to an open file."""
+    fp.write(dumps(ob))
+

shapely/predicates.py

@@ -16,20 +16,16 @@ 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):
-        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))
+        retval = self.fn(self.context._geom, other._geom)
+        if retval == 2:
+            raise PredicateError, "Failed to evaluate %s" % repr(self.fn)
+        return bool(retval)
 
 
 # A data descriptor
@@ -42,16 +38,12 @@ 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):
-        if obj._geom is None:
-            raise ValueError, "Null geometry supports no operations"
-        return bool(self.fn(obj._geom))
+        retval = self.fn(obj._geom)
+        if retval == 2:
+            raise PredicateError, "Failed to evaluate %s" % repr(self.fn)
+        return bool(retval)
     
     def __set__(self, obj, value=None):
         raise AttributeError, "Attribute is read-only"

shapely/topology.py

@@ -26,19 +26,7 @@ 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
-            if not self.context.is_valid:
-                raise TopologicalError, \
-                "The operation '%s' produced a null geometry. Likely cause is invalidity of the geometry %s" % (self.fn.__name__, repr(self.context))
-            elif not other.is_valid:
-                raise TopologicalError, \
-                "The operation '%s' produced a null geometry. Likely cause is invalidity of the 'other' geometry %s" % (self.fn.__name__, repr(other))
-
-        return self.factory(product)
+        return self.factory(self.fn(self.context._geom, other._geom))
 
 
 class UnaryTopologicalOp(object):
@@ -57,8 +45,6 @@ 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, free, ReadingError
+from shapely.geos import lgeos, ReadingError
 from shapely.geometry.base import geom_factory
 
 
@@ -25,14 +25,9 @@ def load(fp):
 
 def dumps(ob):
     """Dump a WKB representation of a geometry to a byte string."""
-    func = lgeos.GEOSGeomToWKB_buf
     size = c_int()
-    def errcheck(result, func, argtuple):
-        retval = string_at(result, size.value)[:]
-        free(result)
-        return retval
-    func.errcheck = errcheck
-    return func(ob._geom, byref(size))
+    bytes = lgeos.GEOSGeomToWKB_buf(ob._geom, byref(size))
+    return string_at(bytes, size.value)
 
 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, free, allocated_c_char_p, ReadingError
+from shapely.geos import lgeos, ReadingError
 from shapely.geometry.base import geom_factory
 
 
@@ -25,14 +25,7 @@ def load(fp):
 
 def dumps(ob):
     """Dump a WKB representation of a geometry to a byte string."""
-    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)
+    return string_at(lgeos.GEOSGeomToWKT(ob._geom))
 
 def dump(ob, fp):
     """Dump a geometry to an open file."""