shapely 1.3.3__cp34-none-win_amd64.whl

shapely/ctypes_declarations.py

@@ -0,0 +1,455 @@
+'''Prototyping of the GEOS C API
+
+See header file: geos-x.y.z/capi/geos_c.h
+'''
+
+from ctypes import CFUNCTYPE, POINTER, c_void_p, c_char_p, \
+    c_size_t, c_byte, c_char, c_uint, c_int, c_double
+
+# Derived pointer types
+c_size_t_p = POINTER(c_size_t)
+
+
+class allocated_c_char_p(c_char_p):
+    '''char pointer return type'''
+    pass
+
+EXCEPTION_HANDLER_FUNCTYPE = CFUNCTYPE(None, c_char_p, c_char_p)
+
+
+def prototype(lgeos, geos_version):
+    '''Protype functions in geos_c.h for different version of GEOS
+
+    Use the GEOS version, not the C API version.
+    '''
+
+    '''
+    Initialization, cleanup, version
+    '''
+
+    lgeos.initGEOS.restype = None
+    lgeos.initGEOS.argtypes = [EXCEPTION_HANDLER_FUNCTYPE, EXCEPTION_HANDLER_FUNCTYPE]
+
+    lgeos.finishGEOS.restype = None
+    lgeos.finishGEOS.argtypes = []
+
+    lgeos.GEOSversion.restype = c_char_p
+    lgeos.GEOSversion.argtypes = []
+
+    '''
+    NOTE - These functions are DEPRECATED.  Please use the new Reader and
+    writer APIS!
+    '''
+
+    lgeos.GEOSGeomFromWKT.restype = c_void_p
+    lgeos.GEOSGeomFromWKT.argtypes = [c_char_p]
+
+    lgeos.GEOSGeomToWKT.restype = allocated_c_char_p
+    lgeos.GEOSGeomToWKT.argtypes = [c_void_p]
+
+    lgeos.GEOS_setWKBOutputDims.restype = c_int
+    lgeos.GEOS_setWKBOutputDims.argtypes = [c_int]
+
+    lgeos.GEOSGeomFromWKB_buf.restype = c_void_p
+    lgeos.GEOSGeomFromWKB_buf.argtypes = [c_void_p, c_size_t]
+
+    lgeos.GEOSGeomToWKB_buf.restype = allocated_c_char_p
+    lgeos.GEOSGeomToWKB_buf.argtypes = [c_void_p, c_size_t_p]
+
+    '''
+    Coordinate sequence
+    '''
+
+    lgeos.GEOSCoordSeq_create.restype = c_void_p
+    lgeos.GEOSCoordSeq_create.argtypes = [c_uint, c_uint]
+
+    lgeos.GEOSCoordSeq_clone.restype = c_void_p
+    lgeos.GEOSCoordSeq_clone.argtypes = [c_void_p]
+
+    lgeos.GEOSCoordSeq_destroy.restype = None
+    lgeos.GEOSCoordSeq_destroy.argtypes = [c_void_p]
+
+    lgeos.GEOSCoordSeq_setX.restype = c_int
+    lgeos.GEOSCoordSeq_setX.argtypes = [c_void_p, c_uint, c_double]
+
+    lgeos.GEOSCoordSeq_setY.restype = c_int
+    lgeos.GEOSCoordSeq_setY.argtypes = [c_void_p, c_uint, c_double]
+
+    lgeos.GEOSCoordSeq_setZ.restype = c_int
+    lgeos.GEOSCoordSeq_setZ.argtypes = [c_void_p, c_uint, c_double]
+
+    lgeos.GEOSCoordSeq_setOrdinate.restype = c_int
+    lgeos.GEOSCoordSeq_setOrdinate.argtypes = [c_void_p, c_uint, c_uint, c_double]
+
+    lgeos.GEOSCoordSeq_getX.restype = c_int
+    lgeos.GEOSCoordSeq_getX.argtypes = [c_void_p, c_uint, c_void_p]
+
+    lgeos.GEOSCoordSeq_getY.restype = c_int
+    lgeos.GEOSCoordSeq_getY.argtypes = [c_void_p, c_uint, c_void_p]
+
+    lgeos.GEOSCoordSeq_getZ.restype = c_int
+    lgeos.GEOSCoordSeq_getZ.argtypes = [c_void_p, c_uint, c_void_p]
+
+    lgeos.GEOSCoordSeq_getSize.restype = c_int
+    lgeos.GEOSCoordSeq_getSize.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSCoordSeq_getDimensions.restype = c_int
+    lgeos.GEOSCoordSeq_getDimensions.argtypes = [c_void_p, c_void_p]
+
+    '''
+    Linear refeferencing
+    '''
+
+    if geos_version >= (3, 2, 0):
+
+        lgeos.GEOSProject.restype = c_double
+        lgeos.GEOSProject.argtypes = [c_void_p, c_void_p]
+
+        lgeos.GEOSInterpolate.restype = c_void_p
+        lgeos.GEOSInterpolate.argtypes = [c_void_p, c_double]
+
+        lgeos.GEOSProjectNormalized.restype = c_double
+        lgeos.GEOSProjectNormalized.argtypes = [c_void_p, c_void_p]
+
+        lgeos.GEOSInterpolateNormalized.restype = c_void_p
+        lgeos.GEOSInterpolateNormalized.argtypes = [c_void_p, c_double]
+
+    '''
+    Buffer related
+    '''
+
+    lgeos.GEOSBuffer.restype = c_void_p
+    lgeos.GEOSBuffer.argtypes = [c_void_p, c_double, c_int]
+
+    if geos_version >= (3, 2, 0):
+
+        lgeos.GEOSBufferWithStyle.restype = c_void_p
+        lgeos.GEOSBufferWithStyle.argtypes = [c_void_p, c_double, c_int, c_int, c_int, c_double]
+
+        lgeos.GEOSSingleSidedBuffer.restype = c_void_p
+        lgeos.GEOSSingleSidedBuffer.argtypes = [c_void_p, c_double, c_int, c_int, c_double, c_int]
+
+    '''
+    Geometry constructors
+    '''
+
+    lgeos.GEOSGeom_createPoint.restype = c_void_p
+    lgeos.GEOSGeom_createPoint.argtypes = [c_void_p]
+
+    lgeos.GEOSGeom_createLinearRing.restype = c_void_p
+    lgeos.GEOSGeom_createLinearRing.argtypes = [c_void_p]
+
+    lgeos.GEOSGeom_createLineString.restype = c_void_p
+    lgeos.GEOSGeom_createLineString.argtypes = [c_void_p]
+
+    lgeos.GEOSGeom_createPolygon.restype = c_void_p
+    lgeos.GEOSGeom_createPolygon.argtypes = [c_void_p, c_void_p, c_uint]
+
+    lgeos.GEOSGeom_createCollection.restype = c_void_p
+    lgeos.GEOSGeom_createCollection.argtypes = [c_int, c_void_p, c_uint]
+
+    lgeos.GEOSGeom_clone.restype = c_void_p
+    lgeos.GEOSGeom_clone.argtypes = [c_void_p]
+
+    '''
+    Memory management
+    '''
+
+    lgeos.GEOSGeom_destroy.restype = None
+    lgeos.GEOSGeom_destroy.argtypes = [c_void_p]
+
+    '''
+    Topology operations
+    Return NULL on exception
+    '''
+
+    lgeos.GEOSEnvelope.restype = c_void_p
+    lgeos.GEOSEnvelope.argtypes = [c_void_p]
+
+    lgeos.GEOSIntersection.restype = c_void_p
+    lgeos.GEOSIntersection.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSConvexHull.restype = c_void_p
+    lgeos.GEOSConvexHull.argtypes = [c_void_p]
+
+    lgeos.GEOSDifference.restype = c_void_p
+    lgeos.GEOSDifference.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSSymDifference.restype = c_void_p
+    lgeos.GEOSSymDifference.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSBoundary.restype = c_void_p
+    lgeos.GEOSBoundary.argtypes = [c_void_p]
+
+    lgeos.GEOSUnion.restype = c_void_p
+    lgeos.GEOSUnion.argtypes = [c_void_p, c_void_p]
+
+    if geos_version >= (3, 3, 0):
+        lgeos.GEOSUnaryUnion.restype = c_void_p
+        lgeos.GEOSUnaryUnion.argtypes = [c_void_p]
+
+    if geos_version >= (3, 1, 0):
+        '''deprecated in 3.3.0: use GEOSUnaryUnion instead'''
+        lgeos.GEOSUnionCascaded.restype = c_void_p
+        lgeos.GEOSUnionCascaded.argtypes = [c_void_p]
+
+    lgeos.GEOSPointOnSurface.restype = c_void_p
+    lgeos.GEOSPointOnSurface.argtypes = [c_void_p]
+
+    lgeos.GEOSGetCentroid.restype = c_void_p
+    lgeos.GEOSGetCentroid.argtypes = [c_void_p]
+
+    lgeos.GEOSPolygonize.restype = c_void_p
+    lgeos.GEOSPolygonize.argtypes = [c_void_p, c_uint]
+
+    if geos_version >= (3, 3, 0):
+        lgeos.GEOSPolygonize_full.restype = c_void_p
+        lgeos.GEOSPolygonize_full.argtypes = [c_void_p, c_void_p, c_void_p, c_void_p]
+
+    lgeos.GEOSLineMerge.restype = c_void_p
+    lgeos.GEOSLineMerge.argtypes = [c_void_p]
+
+    lgeos.GEOSSimplify.restype = c_void_p
+    lgeos.GEOSSimplify.argtypes = [c_void_p, c_double]
+
+    lgeos.GEOSTopologyPreserveSimplify.restype = c_void_p
+    lgeos.GEOSTopologyPreserveSimplify.argtypes = [c_void_p, c_double]
+
+    '''
+    Binary predicates
+    Return 2 on exception, 1 on true, 0 on false
+    '''
+
+    lgeos.GEOSDisjoint.restype = c_byte
+    lgeos.GEOSDisjoint.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSTouches.restype = c_byte
+    lgeos.GEOSTouches.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSIntersects.restype = c_byte
+    lgeos.GEOSIntersects.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSCrosses.restype = c_byte
+    lgeos.GEOSCrosses.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSWithin.restype = c_byte
+    lgeos.GEOSWithin.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSContains.restype = c_byte
+    lgeos.GEOSContains.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSOverlaps.restype = c_byte
+    lgeos.GEOSOverlaps.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSEquals.restype = c_byte
+    lgeos.GEOSEquals.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSEqualsExact.restype = c_byte
+    lgeos.GEOSEqualsExact.argtypes = [c_void_p, c_void_p, c_double]
+
+    '''
+    Unary predicate
+    Return 2 on exception, 1 on true, 0 on false
+    '''
+
+    lgeos.GEOSisEmpty.restype = c_byte
+    lgeos.GEOSisEmpty.argtypes = [c_void_p]
+
+    lgeos.GEOSisValid.restype = c_byte
+    lgeos.GEOSisValid.argtypes = [c_void_p]
+
+    if geos_version >= (3, 1, 0):
+        lgeos.GEOSisValidReason.restype = allocated_c_char_p
+        lgeos.GEOSisValidReason.argtypes = [c_void_p]
+
+    lgeos.GEOSisSimple.restype = c_byte
+    lgeos.GEOSisSimple.argtypes = [c_void_p]
+
+    lgeos.GEOSisRing.restype = c_byte
+    lgeos.GEOSisRing.argtypes = [c_void_p]
+
+    lgeos.GEOSHasZ.restype = c_byte
+    lgeos.GEOSHasZ.argtypes = [c_void_p]
+
+    '''
+    Dimensionally Extended 9 Intersection Model related
+    '''
+
+    lgeos.GEOSRelatePattern.restype = c_char
+    lgeos.GEOSRelatePattern.argtypes = [c_void_p, c_void_p, c_char_p]
+
+    lgeos.GEOSRelate.restype = allocated_c_char_p
+    lgeos.GEOSRelate.argtypes = [c_void_p, c_void_p]
+
+    '''
+    Prepared Geometry Binary predicates
+    Return 2 on exception, 1 on true, 0 on false
+    '''
+
+    if geos_version >= (3, 1, 0):
+
+        lgeos.GEOSPrepare.restype = c_void_p
+        lgeos.GEOSPrepare.argtypes = [c_void_p]
+
+        lgeos.GEOSPreparedGeom_destroy.restype = None
+        lgeos.GEOSPreparedGeom_destroy.argtypes = [c_void_p]
+
+        lgeos.GEOSPreparedContains.restype = c_int
+        lgeos.GEOSPreparedContains.argtypes = [c_void_p, c_void_p]
+
+        lgeos.GEOSPreparedContainsProperly.restype = c_int
+        lgeos.GEOSPreparedContainsProperly.argtypes = [c_void_p, c_void_p]
+
+        lgeos.GEOSPreparedCovers.restype = c_int
+        lgeos.GEOSPreparedCovers.argtypes = [c_void_p, c_void_p]
+
+        lgeos.GEOSPreparedIntersects.restype = c_int
+        lgeos.GEOSPreparedIntersects.argtypes = [c_void_p, c_void_p]
+
+    '''
+    Geometry info
+    '''
+
+    lgeos.GEOSGeomType.restype = c_char_p
+    lgeos.GEOSGeomType.argtypes = [c_void_p]
+
+    lgeos.GEOSGeomTypeId.restype = c_int
+    lgeos.GEOSGeomTypeId.argtypes = [c_void_p]
+
+    lgeos.GEOSGetSRID.restype = c_int
+    lgeos.GEOSGetSRID.argtypes = [c_void_p]
+
+    lgeos.GEOSSetSRID.restype = None
+    lgeos.GEOSSetSRID.argtypes = [c_void_p, c_int]
+
+    lgeos.GEOSGetNumGeometries.restype = c_int
+    lgeos.GEOSGetNumGeometries.argtypes = [c_void_p]
+
+    lgeos.GEOSGetGeometryN.restype = c_void_p
+    lgeos.GEOSGetGeometryN.argtypes = [c_void_p, c_int]
+
+    lgeos.GEOSGetNumInteriorRings.restype = c_int
+    lgeos.GEOSGetNumInteriorRings.argtypes = [c_void_p]
+
+    lgeos.GEOSGetInteriorRingN.restype = c_void_p
+    lgeos.GEOSGetInteriorRingN.argtypes = [c_void_p, c_int]
+
+    lgeos.GEOSGetExteriorRing.restype = c_void_p
+    lgeos.GEOSGetExteriorRing.argtypes = [c_void_p]
+
+    lgeos.GEOSGetNumCoordinates.restype = c_int
+    lgeos.GEOSGetNumCoordinates.argtypes = [c_void_p]
+
+    lgeos.GEOSGeom_getCoordSeq.restype = c_void_p
+    lgeos.GEOSGeom_getCoordSeq.argtypes = [c_void_p]
+
+    lgeos.GEOSGeom_getDimensions.restype = c_int
+    lgeos.GEOSGeom_getDimensions.argtypes = [c_void_p]
+
+    '''
+    Misc functions
+    '''
+
+    lgeos.GEOSArea.restype = c_double
+    lgeos.GEOSArea.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSLength.restype = c_int
+    lgeos.GEOSLength.argtypes = [c_void_p, c_void_p]
+
+    lgeos.GEOSDistance.restype = c_int
+    lgeos.GEOSDistance.argtypes = [c_void_p, c_void_p, c_void_p]
+
+    '''
+    Reader and Writer APIs
+    '''
+
+    '''WKT Reader'''
+    lgeos.GEOSWKTReader_create.restype = c_void_p
+    lgeos.GEOSWKTReader_create.argtypes = []
+
+    lgeos.GEOSWKTReader_destroy.restype = None
+    lgeos.GEOSWKTReader_destroy.argtypes = [c_void_p]
+
+    lgeos.GEOSWKTReader_read.restype = c_void_p
+    lgeos.GEOSWKTReader_read.argtypes = [c_void_p, c_char_p]
+
+    '''WKT Writer'''
+    lgeos.GEOSWKTWriter_create.restype = c_void_p
+    lgeos.GEOSWKTWriter_create.argtypes = []
+
+    lgeos.GEOSWKTWriter_destroy.restype = None
+    lgeos.GEOSWKTWriter_destroy.argtypes = [c_void_p]
+
+    lgeos.GEOSWKTWriter_write.restype = allocated_c_char_p
+    lgeos.GEOSWKTWriter_write.argtypes = [c_void_p, c_void_p]
+
+    if geos_version >= (3, 3, 0):
+
+        lgeos.GEOSWKTWriter_setTrim.restype = None
+        lgeos.GEOSWKTWriter_setTrim.argtypes = [c_void_p, c_int]
+
+        lgeos.GEOSWKTWriter_setRoundingPrecision.restype = None
+        lgeos.GEOSWKTWriter_setRoundingPrecision.argtypes = [c_void_p, c_int]
+
+        lgeos.GEOSWKTWriter_setOutputDimension.restype = None
+        lgeos.GEOSWKTWriter_setOutputDimension.argtypes = [c_void_p, c_int]
+
+        lgeos.GEOSWKTWriter_getOutputDimension.restype = c_int
+        lgeos.GEOSWKTWriter_getOutputDimension.argtypes = [c_void_p]
+
+        lgeos.GEOSWKTWriter_setOld3D.restype = None
+        lgeos.GEOSWKTWriter_setOld3D.argtypes = [c_void_p, c_int]
+
+    '''WKB Reader'''
+    lgeos.GEOSWKBReader_create.restype = c_void_p
+    lgeos.GEOSWKBReader_create.argtypes = []
+
+    lgeos.GEOSWKBReader_destroy.restype = None
+    lgeos.GEOSWKBReader_destroy.argtypes = [c_void_p]
+
+    lgeos.GEOSWKBReader_read.restype = c_void_p
+    lgeos.GEOSWKBReader_read.argtypes = [c_void_p, c_char_p, c_size_t]
+
+    lgeos.GEOSWKBReader_readHEX.restype = c_void_p
+    lgeos.GEOSWKBReader_readHEX.argtypes = [c_void_p, c_char_p, c_size_t]
+
+    '''WKB Writer'''
+    lgeos.GEOSWKBWriter_create.restype = c_void_p
+    lgeos.GEOSWKBWriter_create.argtypes = []
+
+    lgeos.GEOSWKBWriter_destroy.restype = None
+    lgeos.GEOSWKBWriter_destroy.argtypes = [c_void_p]
+
+    lgeos.GEOSWKBWriter_write.restype = allocated_c_char_p
+    lgeos.GEOSWKBWriter_write.argtypes = [c_void_p, c_void_p, c_size_t_p]
+
+    lgeos.GEOSWKBWriter_writeHEX.restype = allocated_c_char_p
+    lgeos.GEOSWKBWriter_writeHEX.argtypes = [c_void_p, c_void_p, c_size_t_p]
+
+    lgeos.GEOSWKBWriter_getOutputDimension.restype = c_int
+    lgeos.GEOSWKBWriter_getOutputDimension.argtypes = [c_void_p]
+
+    lgeos.GEOSWKBWriter_setOutputDimension.restype = None
+    lgeos.GEOSWKBWriter_setOutputDimension.argtypes = [c_void_p, c_int]
+
+    lgeos.GEOSWKBWriter_getByteOrder.restype = c_int
+    lgeos.GEOSWKBWriter_getByteOrder.argtypes = [c_void_p]
+
+    lgeos.GEOSWKBWriter_setByteOrder.restype = None
+    lgeos.GEOSWKBWriter_setByteOrder.argtypes = [c_void_p, c_int]
+
+    lgeos.GEOSWKBWriter_getIncludeSRID.restype = c_int
+    lgeos.GEOSWKBWriter_getIncludeSRID.argtypes = [c_void_p]
+
+    lgeos.GEOSWKBWriter_setIncludeSRID.restype = None
+    lgeos.GEOSWKBWriter_setIncludeSRID.argtypes = [c_void_p, c_int]
+
+    if geos_version >= (3, 1, 1):
+
+        '''
+        Free buffers returned by stuff like GEOSWKBWriter_write(),
+        GEOSWKBWriter_writeHEX() and GEOSWKTWriter_write()
+        '''
+
+        lgeos.GEOSFree.restype = None
+        lgeos.GEOSFree.argtypes = [c_void_p]

shapely/examples/__init__.py

@@ -0,0 +1 @@
+# Examples module

shapely/examples/dissolve.py

@@ -0,0 +1,53 @@
+# dissolve.py
+#
+# Demonstrate how Shapely can be used to build up a collection of patches by 
+# dissolving circular regions and how Shapely supports plotting of the results.
+
+from functools import partial
+import random
+
+import pylab
+
+from shapely.geometry import Point
+from shapely.ops import cascaded_union
+
+# Use a partial function to make 100 points uniformly distributed in a 40x40 
+# box centered on 0,0.
+r = partial(random.uniform, -20.0, 20.0)
+points = [Point(r(), r()) for i in range(100)]
+
+# Buffer the points, producing 100 polygon spots
+spots = [p.buffer(2.5) for p in points]
+
+# Perform a cascaded union of the polygon spots, dissolving them into a 
+# collection of polygon patches
+patches = cascaded_union(spots)
+
+if __name__ == "__main__":
+    # Illustrate the results using matplotlib's pylab interface
+    pylab.figure(num=None, figsize=(4, 4), dpi=180)
+    
+    for patch in patches.geoms:
+        assert patch.geom_type in ['Polygon']
+        assert patch.is_valid
+    
+        # Fill and outline each patch
+        x, y = patch.exterior.xy
+        pylab.fill(x, y, color='#cccccc', aa=True) 
+        pylab.plot(x, y, color='#666666', aa=True, lw=1.0)
+    
+        # Do the same for the holes of the patch
+        for hole in patch.interiors:
+            x, y = hole.xy
+            pylab.fill(x, y, color='#ffffff', aa=True) 
+            pylab.plot(x, y, color='#999999', aa=True, lw=1.0)
+    
+    # Plot the original points
+    pylab.plot([p.x for p in points], [p.y for p in points], 'b,', alpha=0.75)
+    
+    # Write the number of patches and the total patch area to the figure
+    pylab.text(-25, 25, 
+        "Patches: %d, total area: %.2f" % (len(patches.geoms), patches.area))
+    
+    pylab.savefig('dissolve.png')
+    

shapely/examples/geoms.py

@@ -0,0 +1,51 @@
+from numpy import asarray
+import pylab
+from shapely.geometry import Point, LineString, Polygon
+
+polygon = Polygon(((-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0)))
+
+point_r = Point(-1.5, 1.2)
+point_g = Point(-1.0, 1.0)
+point_b = Point(-0.5, 0.5)
+
+line_r = LineString(((-0.5, 0.5), (0.5, 0.5)))
+line_g = LineString(((1.0, -1.0), (1.8, 0.5)))
+line_b = LineString(((-1.8, -1.2), (1.8, 0.5)))
+
+def plot_point(g, o, l):
+    pylab.plot([g.x], [g.y], o, label=l)
+
+def plot_line(g, o):
+    a = asarray(g)
+    pylab.plot(a[:,0], a[:,1], o)
+
+def fill_polygon(g, o):
+    a = asarray(g.exterior)
+    pylab.fill(a[:,0], a[:,1], o, alpha=0.5)
+
+def fill_multipolygon(g, o):
+    for g in g.geoms:
+        fill_polygon(g, o)
+
+if __name__ == "__main__":
+    from numpy import asarray
+    import pylab
+    
+    fig = pylab.figure(1, figsize=(4, 3), dpi=150)
+    #pylab.axis([-2.0, 2.0, -1.5, 1.5])
+    pylab.axis('tight')
+
+    a = asarray(polygon.exterior)
+    pylab.fill(a[:,0], a[:,1], 'c')
+
+    plot_point(point_r, 'ro', 'b')
+    plot_point(point_g, 'go', 'c')
+    plot_point(point_b, 'bo', 'd')
+
+    plot_line(line_r, 'r')
+    plot_line(line_g, 'g')
+    plot_line(line_b, 'b')
+
+    pylab.show()
+
+

shapely/examples/intersect.py

@@ -0,0 +1,81 @@
+# intersect.py
+#
+# Demonstrate how Shapely can be used to analyze and plot the intersection of
+# a trajectory and regions in space.
+
+from functools import partial
+import random
+
+import pylab
+
+from shapely.geometry import LineString, Point
+from shapely.ops import cascaded_union
+
+# Build patches as in dissolved.py
+r = partial(random.uniform, -20.0, 20.0)
+points = [Point(r(), r()) for i in range(100)]
+spots = [p.buffer(2.5) for p in points]
+patches = cascaded_union(spots)
+
+# Represent the following geolocation parameters
+#
+# initial position: -25, -25
+# heading: 45.0
+# speed: 50*sqrt(2)
+#
+# as a line
+vector = LineString(((-25.0, -25.0), (25.0, 25.0)))
+
+# Find intercepted and missed patches. List the former so we can count them
+# later
+intercepts = [patch for patch in patches.geoms if vector.intersects(patch)]
+misses = (patch for patch in patches.geoms if not vector.intersects(patch))
+
+# Plot the intersection
+intersection = vector.intersection(patches)
+assert intersection.geom_type in ['MultiLineString']
+
+if __name__ == "__main__":
+    # Illustrate the results using matplotlib's pylab interface
+    pylab.figure(num=None, figsize=(4, 4), dpi=180)
+    
+    # Plot the misses
+    for spot in misses:
+        x, y = spot.exterior.xy
+        pylab.fill(x, y, color='#cccccc', aa=True) 
+        pylab.plot(x, y, color='#999999', aa=True, lw=1.0)
+    
+        # Do the same for the holes of the patch
+        for hole in spot.interiors:
+            x, y = hole.xy
+            pylab.fill(x, y, color='#ffffff', aa=True) 
+            pylab.plot(x, y, color='#999999', aa=True, lw=1.0)
+    
+    # Plot the intercepts
+    for spot in intercepts:
+        x, y = spot.exterior.xy
+        pylab.fill(x, y, color='red', alpha=0.25, aa=True) 
+        pylab.plot(x, y, color='red', alpha=0.5, aa=True, lw=1.0)
+    
+        # Do the same for the holes of the patch
+        for hole in spot.interiors:
+            x, y = hole.xy
+            pylab.fill(x, y, color='#ffffff', aa=True) 
+            pylab.plot(x, y, color='red', alpha=0.5, aa=True, lw=1.0)
+    
+    # Draw the projected trajectory
+    pylab.arrow(-25, -25, 50, 50, color='#999999', aa=True,
+        head_width=1.0, head_length=1.0)
+    
+    for segment in intersection.geoms:
+        x, y = segment.xy
+        pylab.plot(x, y, color='red', aa=True, lw=1.5)
+    
+    # Write the number of patches and the total patch area to the figure
+    pylab.text(-28, 25, 
+        "Patches: %d/%d (%d), total length: %.1f" \
+         % (len(intercepts), len(patches.geoms), 
+            len(intersection.geoms), intersection.length))
+    
+    pylab.savefig('intersect.png')
+    

shapely/examples/world.py

@@ -0,0 +1,21 @@
+import ogr
+import pylab
+from numpy import asarray
+
+from shapely.wkb import loads
+
+source = ogr.Open("/var/gis/data/world/world_borders.shp")
+borders = source.GetLayerByName("world_borders")
+
+fig = pylab.figure(1, figsize=(4,2), dpi=300)
+
+while 1:
+    feature = borders.GetNextFeature()
+    if not feature:
+        break
+    
+    geom = loads(feature.GetGeometryRef().ExportToWkb())
+    a = asarray(geom)
+    pylab.plot(a[:,0], a[:,1])
+
+pylab.show()