shapely 1.2.8__py2.6-win-amd64.egg

shapely/geos.py

@@ -0,0 +1,373 @@
+"""
+Proxies for the libgeos_c shared lib, GEOS-specific exceptions, and utilities
+"""
+
+import atexit
+import logging
+import os
+import sys
+import time
+import threading
+import ctypes
+from ctypes import cdll, CDLL, PyDLL, CFUNCTYPE, c_char_p, c_void_p, string_at
+from ctypes.util import find_library
+
+import ftools
+from ctypes_declarations import prototype
+
+
+
+# Begin by creating a do-nothing handler and adding to this module's logger.
+class NullHandler(logging.Handler):
+    def emit(self, record):
+        pass
+LOG = logging.getLogger(__name__)
+LOG.addHandler(NullHandler())
+
+# Find and load the GEOS and C libraries
+# If this ever gets any longer, we'll break it into separate modules
+
+def load_dll(libname, fallbacks=None):
+    lib = find_library(libname)
+    if lib is not None:
+        return CDLL(lib)
+    else:
+        if fallbacks is not None:
+            for name in fallbacks:
+                try:
+                    return CDLL(name)
+                except OSError:
+                    # move on to the next fallback
+                    pass
+        # the end
+        raise OSError(
+            "Could not find library %s or load any of its variants %s" % (
+                libname, fallbacks or []))
+       
+if sys.platform == 'linux2':
+    _lgeos = load_dll('geos_c', fallbacks=['libgeos_c.so.1', 'libgeos_c.so'])
+    free = load_dll('c').free
+    free.argtypes = [c_void_p]
+    free.restype = None
+
+elif sys.platform == 'darwin':
+    alt_paths = [
+            # The Framework build from Kyng Chaos:
+            "/Library/Frameworks/GEOS.framework/Versions/Current/GEOS",
+            # macports
+            '/opt/local/lib/libgeos_c.dylib',
+    ]
+    _lgeos = load_dll('geos_c', fallbacks=alt_paths)
+    free = load_dll('c').free
+    free.argtypes = [c_void_p]
+    free.restype = None
+
+elif sys.platform == 'win32':
+    try:
+        egg_dlls = os.path.abspath(os.path.join(os.path.dirname(__file__),
+                                     r"..\DLLs"))
+        wininst_dlls =  os.path.abspath(os.__file__ + "../../../DLLs")
+        original_path = os.environ['PATH']
+        os.environ['PATH'] = "%s;%s;%s" % (egg_dlls, wininst_dlls, original_path)
+        _lgeos = CDLL("geos.dll")
+    except (ImportError, WindowsError, OSError):
+        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 == 'sunos5':
+    _lgeos = load_dll('geos_c', fallbacks=['libgeos_c.so.1', 'libgeos_c.so'])
+    free = CDLL('libc.so.1').free
+    free.argtypes = [c_void_p]
+    free.restype = None
+
+else: # other *nix systems
+    _lgeos = load_dll('geos_c', fallbacks=['libgeos_c.so.1', 'libgeos_c.so'])
+    free = load_dll('c', fallbacks=['libc.so.6']).free
+    free.argtypes = [c_void_p]
+    free.restype = None
+
+def _geos_c_version():
+    func = _lgeos.GEOSversion
+    func.restype = c_char_p
+    v = func().split('-')[2]
+    return tuple(int(n) for n in v.split('.'))
+
+geos_capi_version = geos_c_version = _geos_c_version()
+
+# If we have the new interface, then record a baseline so that we know what
+# additional functions are declared in ctypes_declarations.
+if geos_c_version >= (1,5,0):
+    start_set = set(_lgeos.__dict__)
+
+# Apply prototypes for the libgeos_c functions
+prototype(_lgeos, geos_c_version)
+
+# If we have the new interface, automatically detect all function
+# declarations, and declare their re-entrant counterpart.
+if geos_c_version >= (1,5,0):
+    end_set = set(_lgeos.__dict__)
+    new_func_names = end_set - start_set
+    
+    for func_name in new_func_names:
+        new_func_name = "%s_r" % func_name
+        if hasattr(_lgeos, new_func_name):
+            new_func = getattr(_lgeos, new_func_name)
+            old_func = getattr(_lgeos, func_name)
+            new_func.restype = old_func.restype
+            if old_func.argtypes is None:
+                # Handle functions that didn't take an argument before,
+                # finishGEOS.
+                new_func.argtypes = [c_void_p]
+            else:
+                new_func.argtypes = [c_void_p] + old_func.argtypes
+            if old_func.errcheck is not None:
+                new_func.errcheck = old_func.errcheck
+    
+    # Handle special case.
+    _lgeos.initGEOS_r.restype = c_void_p
+    _lgeos.initGEOS_r.argtypes = [c_void_p, c_void_p]
+    _lgeos.finishGEOS_r.argtypes = [c_void_p]
+
+# Exceptions
+
+class ReadingError(Exception):
+    pass
+
+class DimensionError(Exception):
+    pass
+
+class TopologicalError(Exception):
+    pass
+
+class PredicateError(Exception):
+    pass
+
+def error_handler(fmt, list):
+    LOG.error("%s", list)
+error_h = CFUNCTYPE(None, c_char_p, c_char_p)(error_handler)
+
+def notice_handler(fmt, list):
+    LOG.warning("%s", list)
+notice_h = CFUNCTYPE(None, c_char_p, c_char_p)(notice_handler)
+
+def cleanup():
+    if _lgeos is not None :
+        _lgeos.finishGEOS()
+
+atexit.register(cleanup)
+
+# Errcheck functions
+
+def errcheck_wkb(result, func, argtuple):
+    if not result:
+        return None
+    size_ref = argtuple[-1]
+    size = size_ref._obj
+    retval = ctypes.string_at(result, size.value)[:]
+    lgeos.GEOSFree(result)
+    return retval
+
+def errcheck_just_free(result, func, argtuple):
+    retval = string_at(result)
+    lgeos.GEOSFree(result)
+    return retval
+
+def errcheck_predicate(result, func, argtuple):
+    if result == 2:
+        raise PredicateError("Failed to evaluate %s" % repr(func))
+    return result
+
+
+class LGEOSBase(threading.local):
+    """Proxy for the GEOS_C DLL/SO
+
+    This is a base class. Do not instantiate.
+    """
+    methods = {}
+    def __init__(self, dll):
+        self._lgeos = dll
+        self.geos_handle = None
+        
+
+class LGEOS14(LGEOSBase):    
+    """Proxy for the GEOS_C DLL/SO API version 1.4
+    """
+    geos_capi_version = (1, 4, 0)
+    def __init__(self, dll):
+        super(LGEOS14, self).__init__(dll)
+        self.geos_handle = self._lgeos.initGEOS(notice_h, error_h)
+        keys = self._lgeos.__dict__.keys()
+        for key in keys:
+            setattr(self, key, getattr(self._lgeos, key))
+        self.GEOSFree = self._lgeos.free
+        self.GEOSGeomToWKB_buf.errcheck = errcheck_wkb
+        self.GEOSGeomToWKT.errcheck = errcheck_just_free
+        self.GEOSRelate.errcheck = errcheck_just_free
+        for pred in ( self.GEOSDisjoint,
+              self.GEOSTouches,
+              self.GEOSIntersects,
+              self.GEOSCrosses,
+              self.GEOSWithin,
+              self.GEOSContains,
+              self.GEOSOverlaps,
+              self.GEOSEquals,
+              self.GEOSEqualsExact,
+              self.GEOSisEmpty,
+              self.GEOSisValid,
+              self.GEOSisSimple,
+              self.GEOSisRing,
+              self.GEOSHasZ
+              ):
+            pred.errcheck = errcheck_predicate
+
+        self.methods['area'] = self.GEOSArea
+        self.methods['boundary'] = self.GEOSBoundary
+        self.methods['buffer'] = self.GEOSBuffer
+        self.methods['centroid'] = self.GEOSGetCentroid
+        self.methods['representative_point'] = self.GEOSPointOnSurface
+        self.methods['convex_hull'] = self.GEOSConvexHull
+        self.methods['distance'] = self.GEOSDistance
+        self.methods['envelope'] = self.GEOSEnvelope
+        self.methods['length'] = self.GEOSLength
+        self.methods['has_z'] = self.GEOSHasZ
+        self.methods['is_empty'] = self.GEOSisEmpty
+        self.methods['is_ring'] = self.GEOSisRing
+        self.methods['is_simple'] = self.GEOSisSimple
+        self.methods['is_valid'] = self.GEOSisValid
+        self.methods['disjoint'] = self.GEOSDisjoint
+        self.methods['touches'] = self.GEOSTouches
+        self.methods['intersects'] = self.GEOSIntersects
+        self.methods['crosses'] = self.GEOSCrosses
+        self.methods['within'] = self.GEOSWithin
+        self.methods['contains'] = self.GEOSContains
+        self.methods['overlaps'] = self.GEOSOverlaps
+        self.methods['equals'] = self.GEOSEquals
+        self.methods['equals_exact'] = self.GEOSEqualsExact
+        self.methods['relate'] = self.GEOSRelate
+        self.methods['difference'] = self.GEOSDifference
+        self.methods['symmetric_difference'] = self.GEOSSymDifference
+        self.methods['union'] = self.GEOSUnion
+        self.methods['intersection'] = self.GEOSIntersection
+        self.methods['simplify'] = self.GEOSSimplify
+        self.methods['topology_preserve_simplify'] = \
+            self.GEOSTopologyPreserveSimplify
+
+
+class LGEOS15(LGEOSBase):    
+    """Proxy for the reentrant GEOS_C DLL/SO API version 1.5
+    """
+    geos_capi_version = (1, 5, 0)    
+    def __init__(self, dll):
+        super(LGEOS15, self).__init__(dll)
+        self.geos_handle = self._lgeos.initGEOS_r(notice_h, error_h)
+        keys = self._lgeos.__dict__.keys()
+        for key in filter(lambda x: not x.endswith('_r'), keys):
+            if key + '_r' in keys:
+                reentr_func = getattr(self._lgeos, key + '_r')
+                attr = ftools.partial(reentr_func, self.geos_handle)
+                attr.__name__ = reentr_func.__name__
+                setattr(self, key, attr)
+            else:
+                setattr(self, key, getattr(self._lgeos, key))
+        if not hasattr(self, 'GEOSFree'):
+            self.GEOSFree = self._lgeos.free
+        self.GEOSGeomToWKB_buf.func.errcheck = errcheck_wkb
+        self.GEOSGeomToWKT.func.errcheck = errcheck_just_free
+        self.GEOSRelate.func.errcheck = errcheck_just_free
+        for pred in ( self.GEOSDisjoint,
+              self.GEOSTouches,
+              self.GEOSIntersects,
+              self.GEOSCrosses,
+              self.GEOSWithin,
+              self.GEOSContains,
+              self.GEOSOverlaps,
+              self.GEOSEquals,
+              self.GEOSEqualsExact,
+              self.GEOSisEmpty,
+              self.GEOSisValid,
+              self.GEOSisSimple,
+              self.GEOSisRing,
+              self.GEOSHasZ
+              ):
+            pred.func.errcheck = errcheck_predicate
+
+        self.GEOSisValidReason.func.errcheck = errcheck_just_free
+        
+        self.methods['area'] = self.GEOSArea
+        self.methods['boundary'] = self.GEOSBoundary
+        self.methods['buffer'] = self.GEOSBuffer
+        self.methods['centroid'] = self.GEOSGetCentroid
+        self.methods['representative_point'] = self.GEOSPointOnSurface
+        self.methods['convex_hull'] = self.GEOSConvexHull
+        self.methods['distance'] = self.GEOSDistance
+        self.methods['envelope'] = self.GEOSEnvelope
+        self.methods['length'] = self.GEOSLength
+        self.methods['has_z'] = self.GEOSHasZ
+        self.methods['is_empty'] = self.GEOSisEmpty
+        self.methods['is_ring'] = self.GEOSisRing
+        self.methods['is_simple'] = self.GEOSisSimple
+        self.methods['is_valid'] = self.GEOSisValid
+        self.methods['disjoint'] = self.GEOSDisjoint
+        self.methods['touches'] = self.GEOSTouches
+        self.methods['intersects'] = self.GEOSIntersects
+        self.methods['crosses'] = self.GEOSCrosses
+        self.methods['within'] = self.GEOSWithin
+        self.methods['contains'] = self.GEOSContains
+        self.methods['overlaps'] = self.GEOSOverlaps
+        self.methods['equals'] = self.GEOSEquals
+        self.methods['equals_exact'] = self.GEOSEqualsExact
+        self.methods['relate'] = self.GEOSRelate
+        self.methods['difference'] = self.GEOSDifference
+        self.methods['symmetric_difference'] = self.GEOSSymDifference
+        self.methods['union'] = self.GEOSUnion
+        self.methods['intersection'] = self.GEOSIntersection
+        self.methods['prepared_intersects'] = self.GEOSPreparedIntersects
+        self.methods['prepared_contains'] = self.GEOSPreparedContains
+        self.methods['prepared_contains_properly'] = \
+            self.GEOSPreparedContainsProperly
+        self.methods['prepared_covers'] = self.GEOSPreparedCovers
+        self.methods['simplify'] = self.GEOSSimplify
+        self.methods['topology_preserve_simplify'] = \
+            self.GEOSTopologyPreserveSimplify
+
+class LGEOS16(LGEOS15):
+    """Proxy for the reentrant GEOS_C DLL/SO API version 1.6
+    """
+    geos_capi_version = (1, 6, 0)
+    def __init__(self, dll):
+        super(LGEOS16, self).__init__(dll)
+
+
+class LGEOS16LR(LGEOS16):    
+    """Proxy for the reentrant GEOS_C DLL/SO API version 1.6 with linear
+    referencing
+    """
+    geos_capi_version = geos_c_version
+    def __init__(self, dll):
+        super(LGEOS16LR, self).__init__(dll)
+
+        self.methods['parallel_offset'] = self.GEOSSingleSidedBuffer
+        self.methods['project'] = self.GEOSProject
+        self.methods['project_normalized'] = self.GEOSProjectNormalized
+        self.methods['interpolate'] = self.GEOSInterpolate
+        self.methods['interpolate_normalized'] = \
+            self.GEOSInterpolateNormalized
+
+
+if geos_c_version >= (1, 6, 0):
+    if hasattr(_lgeos, 'GEOSProject'):
+        L = LGEOS16LR
+    else:
+        L = LGEOS16
+elif geos_c_version >= (1, 5, 0):
+        L = LGEOS15
+else:
+        L = LGEOS14
+
+lgeos = L(_lgeos)
+

shapely/impl.py

@@ -0,0 +1,119 @@
+"""Implementation of the intermediary layer between Shapely and GEOS
+
+This is layer number 2 from the list below.
+
+1) geometric objects: the Python OO API.
+2) implementation map: an abstraction that permits different backends.
+3) backend: callable objects that take Shapely geometric objects as arguments 
+   and, with GEOS as a backend, translate them to C data structures.
+4) GEOS library: algorithms implemented in C++.
+
+Shapely 1.2 includes a GEOS backend and it is the default.
+"""
+
+from ftools import wraps
+
+from shapely.coords import BoundsOp
+from shapely.geos import lgeos
+from shapely.linref import ProjectOp, InterpolateOp
+from shapely.predicates import BinaryPredicate, UnaryPredicate
+from shapely.topology import BinaryRealProperty, BinaryTopologicalOp
+from shapely.topology import UnaryRealProperty, UnaryTopologicalOp
+
+def delegated(func):
+    """A delegated method raises AttributeError in the absence of backend 
+    support."""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except KeyError:
+            raise AttributeError, "Method '%s' is not supported by %s" % (
+                func.__name__, repr(args[0].impl))
+    return wrapper
+
+# Map geometry methods to their GEOS delegates
+
+class BaseImpl(object):
+    def __init__(self, values):
+        self.map = dict(values)
+    def update(self, values):
+        self.map.update(values)
+    def __getitem__(self, key):
+        return self.map[key]
+
+class GEOSImpl(BaseImpl):
+    def __repr__(self):
+        return '<GEOSImpl object: GEOS C API version %s>' % (
+            lgeos.geos_capi_version,)
+
+IMPL14 = {
+    'area': (UnaryRealProperty, 'area'),
+    'distance': (BinaryRealProperty, 'distance'),
+    'length': (UnaryRealProperty, 'length'),
+    #
+    'boundary': (UnaryTopologicalOp, 'boundary'),
+    'bounds': (BoundsOp, None),
+    'centroid': (UnaryTopologicalOp, 'centroid'),
+    'representative_point': (UnaryTopologicalOp, 'representative_point'),
+    'envelope': (UnaryTopologicalOp, 'envelope'),
+    'convex_hull': (UnaryTopologicalOp, 'convex_hull'),
+    'buffer': (UnaryTopologicalOp, 'buffer'),
+    #
+    'difference': (BinaryTopologicalOp, 'difference'),
+    'intersection': (BinaryTopologicalOp, 'intersection'),
+    'symmetric_difference': (BinaryTopologicalOp, 'symmetric_difference'),
+    'union': (BinaryTopologicalOp, 'union'),
+    #
+    'has_z': (UnaryPredicate, 'has_z'),
+    'is_empty': (UnaryPredicate, 'is_empty'),
+    'is_ring': (UnaryPredicate, 'is_ring'),
+    'is_simple': (UnaryPredicate, 'is_simple'),
+    'is_valid': (UnaryPredicate, 'is_valid'),
+    #
+    'relate': (BinaryPredicate, 'relate'),
+    'contains': (BinaryPredicate, 'contains'),
+    'crosses': (BinaryPredicate, 'crosses'),
+    'disjoint': (BinaryPredicate, 'disjoint'),
+    'equals': (BinaryPredicate, 'equals'),
+    'intersects': (BinaryPredicate, 'intersects'),
+    'overlaps': (BinaryPredicate, 'overlaps'),
+    'touches': (BinaryPredicate, 'touches'),
+    'within': (BinaryPredicate, 'within'),
+    'equals_exact': (BinaryPredicate, 'equals_exact'),
+    }
+
+IMPL15 = {
+    'simplify': (UnaryTopologicalOp, 'simplify'),
+    'topology_preserve_simplify': 
+        (UnaryTopologicalOp, 'topology_preserve_simplify'),
+    'prepared_intersects': (BinaryPredicate, 'prepared_intersects'),
+    'prepared_contains': (BinaryPredicate, 'prepared_contains'),
+    'prepared_contains_properly': 
+        (BinaryPredicate, 'prepared_contains_properly'),
+    'prepared_covers': (BinaryPredicate, 'prepared_covers'),
+    }
+
+IMPL16 = {
+    }
+
+IMPL16LR = {
+	'parallel_offset': (UnaryTopologicalOp, 'parallel_offset'),
+	'project_normalized': (ProjectOp, 'project_normalized'),
+    'project': (ProjectOp, 'project'),
+    'interpolate_normalized': (InterpolateOp, 'interpolate_normalized'),
+    'interpolate': (InterpolateOp, 'interpolate'),
+    }
+
+def impl_items(defs):
+    return [(k, v[0](v[1])) for k, v in defs.items()]
+
+imp = GEOSImpl(dict(impl_items(IMPL14)))
+if lgeos.geos_capi_version >= (1, 5, 0):
+    imp.update(impl_items(IMPL15))
+if lgeos.geos_capi_version >= (1, 6, 0):
+    imp.update(impl_items(IMPL16))
+    if 'project' in lgeos.methods:
+        imp.update(impl_items(IMPL16LR))
+
+DefaultImplementation = imp

shapely/iterops.py

@@ -0,0 +1,53 @@
+"""
+Iterative forms of operations
+"""
+
+from ctypes import c_char_p, c_size_t
+from shapely.geos import lgeos, free
+
+
+def geos_from_geometry(geom):
+    data = geom.to_wkb()
+    return lgeos.GEOSGeomFromWKB_buf(
+                        c_char_p(data),
+                        c_size_t(len(data))
+                        )
+
+
+class IterOp(object):
+    
+    """A generating non-data descriptor.
+    """
+    
+    def __init__(self, fn):
+        self.fn = fn
+    
+    def __call__(self, context, iterator, value=True):
+        if context._geom is None:
+            raise ValueError("Null geometry supports no operations")
+        for item in iterator:
+            try:
+                this_geom, ob = item
+            except TypeError:
+                this_geom = item
+                ob = this_geom
+            if not this_geom._geom:
+                raise ValueError("Null geometry supports no operations")
+            retval = self.fn(context._geom, this_geom._geom)
+            if retval == 2:
+                raise PredicateError(
+                    "Failed to evaluate %s" % repr(self.fn))
+            elif bool(retval) == value:
+                yield ob
+
+
+# utilities
+disjoint = IterOp(lgeos.GEOSDisjoint)
+touches = IterOp(lgeos.GEOSTouches)
+intersects = IterOp(lgeos.GEOSIntersects)
+crosses = IterOp(lgeos.GEOSCrosses)
+within = IterOp(lgeos.GEOSWithin)
+contains = IterOp(lgeos.GEOSContains)
+overlaps = IterOp(lgeos.GEOSOverlaps)
+equals = IterOp(lgeos.GEOSEquals)
+

shapely/linref.py

@@ -0,0 +1,26 @@
+"""Linear referencing
+"""
+
+from shapely.topology import Delegating
+
+
+class LinearRefBase(Delegating):
+    def _validate_line(self, ob):
+        super(LinearRefBase, self)._validate(ob)
+        try:
+            assert ob.geom_type in ['LineString', 'MultiLineString']
+        except AssertionError:
+            raise TypeError("Only linear types support this operation")
+
+class ProjectOp(LinearRefBase):
+    def __call__(self, this, other):
+        self._validate_line(this)
+        self._validate(other)
+        return self.fn(this._geom, other._geom)
+
+class InterpolateOp(LinearRefBase):
+    def __call__(self, this, distance):
+        self._validate_line(this)
+        return self.fn(this._geom, distance)
+
+

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