shapely 1.2.7__py2.7-win32.egg

shapely/ops.py

@@ -0,0 +1,87 @@
+"""Support for various GEOS geometry operations
+"""
+
+from ctypes import byref, c_void_p
+
+from shapely.geos import lgeos
+from shapely.geometry.base import geom_factory, BaseGeometry
+from shapely.geometry import asShape, asLineString, asMultiLineString
+
+__all__= ['operator', 'polygonize', 'linemerge', 'cascaded_union']
+
+
+class CollectionOperator(object):
+
+    def shapeup(self, ob):
+        if isinstance(ob, BaseGeometry):
+            return ob
+        else:
+            try:
+                return asShape(ob)
+            except ValueError:
+                return asLineString(ob)
+
+    def polygonize(self, lines):
+        """Creates polygons from a source of lines
+        
+        The source may be a MultiLineString, a sequence of LineString objects,
+        or a sequence of objects than can be adapted to LineStrings.
+        """
+        source = getattr(lines, 'geoms', None) or lines
+        obs = [self.shapeup(l) for l in source]
+        geom_array_type = c_void_p * len(obs)
+        geom_array = geom_array_type()
+        for i, line in enumerate(obs):
+            geom_array[i] = line._geom
+        product = lgeos.GEOSPolygonize(byref(geom_array), len(obs))
+        collection = geom_factory(product)
+        for g in collection.geoms:
+            clone = lgeos.GEOSGeom_clone(g._geom)
+            g = geom_factory(clone)
+            g._owned = False
+            yield g
+
+    def linemerge(self, lines): 
+        """Merges all connected lines from a source
+        
+        The source may be a MultiLineString, a sequence of LineString objects,
+        or a sequence of objects than can be adapted to LineStrings.  Returns a
+        LineString or MultiLineString when lines are not contiguous. 
+        """ 
+        source = None 
+        if hasattr(lines, 'type') and lines.type == 'MultiLineString': 
+            source = lines 
+        elif hasattr(lines, '__iter__'): 
+            try: 
+                source = asMultiLineString([ls.coords for ls in lines]) 
+            except AttributeError: 
+                source = asMultiLineString(lines) 
+        if source is None: 
+            raise ValueError("Cannot linemerge %s" % lines)
+        result = lgeos.GEOSLineMerge(source._geom) 
+        return geom_factory(result)   
+
+    def cascaded_union(self, geoms):
+        """Returns the union of a sequence of geometries
+        
+        This is the most efficient method of dissolving many polygons.
+        """
+        L = len(geoms)
+        subs = (c_void_p * L)()
+        for i, g in enumerate(geoms):
+            subs[i] = g._geom
+        collection = lgeos.GEOSGeom_createCollection(6, subs, L)
+        return geom_factory(lgeos.GEOSUnionCascaded(collection))
+
+
+operator = CollectionOperator()
+polygonize = operator.polygonize
+linemerge = operator.linemerge
+cascaded_union = operator.cascaded_union
+
+class ValidateOp(object):
+    def __call__(self, this):
+        return lgeos.GEOSisValidReason(this._geom)
+
+validate = ValidateOp()
+

shapely/predicates.py

@@ -0,0 +1,24 @@
+"""
+Support for GEOS spatial predicates
+"""
+
+from shapely.geos import PredicateError, lgeos
+from shapely.topology import Delegating
+
+class BinaryPredicate(Delegating):
+    def __call__(self, this, other, *args):
+        self._validate(this)
+        self._validate(other)
+        return self.fn(this._geom, other._geom, *args)
+
+class RelateOp(Delegating):
+    def __call__(self, this, other):
+        self._validate(this)
+        self._validate(other)
+        return self.fn(this._geom, other._geom)
+
+class UnaryPredicate(Delegating):
+    def __call__(self, this):
+        self._validate(this)
+        return self.fn(this._geom)
+

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))
+