shapely 1.2.8__py2.7-win-amd64.egg

shapely/prepared.py

@@ -0,0 +1,58 @@
+"""
+Support for GEOS prepared geometry operations.
+"""
+
+from shapely.geos import lgeos
+from shapely.impl import DefaultImplementation, delegated
+
+
+class PreparedGeometry(object):
+    """
+    A geometry prepared for efficient comparison to a set of other geometries.
+    
+    Example:
+      
+      >>> from shapely.geometry import Point, Polygon
+      >>> triangle = Polygon(((0.0, 0.0), (1.0, 1.0), (1.0, -1.0)))
+      >>> p = prep(triangle)
+      >>> p.intersects(Point(0.5, 0.5))
+      True
+    """
+   
+    impl = DefaultImplementation
+    
+    def __init__(self, context):
+        self.context = context
+        self.__geom__ = lgeos.GEOSPrepare(self.context._geom)
+    
+    def __del__(self):
+        if self.__geom__ is not None:
+            lgeos.GEOSPreparedGeom_destroy(self.__geom__)
+        self.__geom__ = None
+        self.context = None
+    
+    @property
+    def _geom(self):
+        return self.__geom__
+   
+    @delegated
+    def intersects(self, other):
+        return bool(self.impl['prepared_intersects'](self, other))
+
+    @delegated
+    def contains(self, other):
+        return bool(self.impl['prepared_contains'](self, other))
+
+    @delegated
+    def contains_properly(self, other):
+        return bool(self.impl['prepared_contains_properly'](self, other))
+
+    @delegated
+    def covers(self, other):
+        return bool(self.impl['prepared_covers'](self, other))
+
+
+def prep(ob):
+    """Creates and returns a prepared geometric object."""
+    return PreparedGeometry(ob)
+

shapely/topology.py

@@ -0,0 +1,62 @@
+"""
+Intermediaries supporting GEOS topological operations
+
+These methods all take Shapely geometries and other Python objects and delegate
+to GEOS functions via ctypes.
+
+These methods return ctypes objects that should be recast by the caller.
+"""
+
+from ctypes import byref, c_double
+from shapely.geos import TopologicalError, lgeos
+
+
+class Validating(object):
+    def _validate(self, ob):
+        try:
+            assert ob is not None
+            assert ob._geom is not None
+        except AssertionError:
+            raise ValueError("Null geometry supports no operations")
+
+class Delegating(Validating):
+    def __init__(self, name):
+        self.fn = lgeos.methods[name]
+
+class BinaryRealProperty(Delegating):
+    def __call__(self, this, other):
+        self._validate(this)
+        self._validate(other)
+        d = c_double()
+        retval = self.fn(this._geom, other._geom, byref(d))
+        return d.value
+
+class UnaryRealProperty(Delegating):
+    def __call__(self, this):
+        self._validate(this)
+        d = c_double()
+        retval = self.fn(this._geom, byref(d))
+        return d.value
+
+class BinaryTopologicalOp(Delegating):
+    def __call__(self, this, other, *args):
+        self._validate(this)
+        self._validate(other)
+        product = self.fn(this._geom, other._geom, *args)
+        if product is None:
+            if not this.is_valid:
+                raise TopologicalError(
+                    "The operation '%s' produced a null geometry. Likely cause is invalidity of the geometry %s" % (self.fn.__name__, repr(this)))
+            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)))
+            else:
+                raise TopologicalError(
+                    "This operation produced a null geometry. Reason: unknown")
+        return product
+
+class UnaryTopologicalOp(Delegating):
+    def __call__(self, this, *args):
+        self._validate(this)
+        return self.fn(this._geom, *args)
+

shapely/validation.py

@@ -0,0 +1,7 @@
+# TODO: allow for implementations using other than GEOS
+
+from shapely.geos import lgeos
+
+def explain_validity(ob):
+    return lgeos.GEOSisValidReason(ob._geom)
+

shapely/wkb.py

@@ -0,0 +1,39 @@
+"""Load/dump geometries using the well-known binary (WKB) format
+"""
+
+from ctypes import byref, c_size_t, c_char_p, string_at
+from ctypes import c_void_p, c_size_t
+
+from shapely.geos import lgeos, ReadingError
+
+
+# Pickle-like convenience functions
+
+def deserialize(data):
+    geom = lgeos.GEOSGeomFromWKB_buf(c_char_p(data), c_size_t(len(data)));
+    if not geom:
+        raise ReadingError(
+            "Could not create geometry because of errors while reading input.")
+    return geom
+
+def loads(data):
+    """Load a geometry from a WKB string."""
+    from shapely.geometry.base import geom_factory
+    return geom_factory(deserialize(data))
+
+def load(fp):
+    """Load a geometry from an open file."""
+    data = fp.read()
+    return loads(data)
+
+def dumps(ob):
+    """Dump a WKB representation of a geometry to a byte string."""
+    if ob is None or ob._geom is None:
+        raise ValueError("Null geometry supports no operations")
+    size = c_size_t()
+    return lgeos.GEOSGeomToWKB_buf(c_void_p(ob._geom), byref(size))
+
+def dump(ob, fp):
+    """Dump a geometry to an open file."""
+    fp.write(dumps(ob))
+

shapely/wkt.py

@@ -0,0 +1,34 @@
+"""Load/dump geometries using the well-known text (WKT) format
+"""
+
+from ctypes import c_char_p
+
+from shapely.geos import lgeos, ReadingError
+
+
+# Pickle-like convenience functions
+
+def loads(data):
+    """Load a geometry from a WKT string."""
+    from shapely.geometry.base import geom_factory
+    geom = lgeos.GEOSGeomFromWKT(c_char_p(data))
+    if not geom:
+        raise ReadingError, \
+        "Could not create geometry because of errors while reading input."
+    return geom_factory(geom)
+
+def load(fp):
+    """Load a geometry from an open file."""
+    data = fp.read()
+    return loads(data)
+
+def dumps(ob):
+    """Dump a WKB representation of a geometry to a byte string."""
+    if ob is None or ob._geom is None:
+        raise ValueError("Null geometry supports no operations")
+    return lgeos.GEOSGeomToWKT(ob._geom)
+
+def dump(ob, fp):
+    """Dump a geometry to an open file."""
+    fp.write(dumps(ob))
+