shapely 1.2.7__py2.7-win32.egg

EGG-INFO/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 1.0
+Name: Shapely
+Version: 1.2.7
+Summary: Geometric objects, predicates, and operations
+Home-page: http://trac.gispython.org/lab/wiki/Shapely
+Author: Sean Gillies
+Author-email: sean.gillies@gmail.com
+License: BSD
+Description: =======
+        Shapely
+        =======
+        
+        .. image:: http://farm3.static.flickr.com/2738/4511827859_b5822043b7_o_d.png
+           :width: 800
+           :height: 400
+        
+        Shapely is a BSD-licensed Python package for manipulation and analysis of
+        planar geometric objects. It is not concerned with data formats or coordinate
+        systems.  It is based on the widely deployed GEOS_ (the engine of PostGIS_) and
+        JTS_ (from which GEOS is ported) libraries. This C dependency is traded for the
+        ability to execute with blazing speed.
+        
+        In a nutshell: Shapely lets you do PostGIS-ish stuff outside the context of a
+        database using idiomatic Python. For more details, see:
+        
+        * Shapely wiki_
+        * Shapely manual_
+        * Shapely `example apps`_
+        
+        Dependencies
+        ------------
+        
+        Shapely 1.2 depends on:
+        
+        * Python >=2.5,<3
+        * libgeos_c >=3.1 (3.0 and below have not been tested, YMMV)
+        
+        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::
+        
+          $ pip install Shapely
+        
+        or from a source distribution with the setup script::
+        
+          $ python setup.py install
+        
+        Usage
+        -----
+        
+        Here is the canonical example of building an approximately circular patch by
+        buffering a point::
+        
+          >>> from shapely.geometry import Point
+          >>> patch = Point(0.0, 0.0).buffer(10.0)
+          >>> patch
+          <shapely.geometry.polygon.Polygon object at 0x...>
+          >>> patch.area
+          313.65484905459385
+        
+        See the manual_ for comprehensive usage snippets and the dissolve.py and
+        intersect.py `example apps`_.
+        
+        Integration 
+        -----------
+        
+        Shapely does not read or write data files, but it can serialize and deserialize
+        using several well known formats and protocols. The shapely.wkb and shapely.wkt
+        modules provide dumpers and loaders inspired by Python's pickle module.::
+        
+          >>> from shapely.wkt import dumps, loads
+          >>> dumps(loads('POINT (0 0)'))
+          'POINT (0.0000000000000000 0.0000000000000000)'
+        
+        All linear objects, such as the rings of a polygon (like ``patch`` above),
+        provide the Numpy array interface.::
+        
+          >>> from numpy import asarray
+          >>> ag = asarray(patch.exterior)
+          >>> ag
+          array([[  1.00000000e+01,   0.00000000e+00],
+                 [  9.95184727e+00,  -9.80171403e-01],
+                 [  9.80785280e+00,  -1.95090322e+00],
+                 ...
+                 [  1.00000000e+01,   0.00000000e+00]])
+        
+        That yields a numpy array of [x, y] arrays. This is not always exactly what one
+        wants for plotting shapes with Matplotlib, so Shapely 1.2 adds a `xy` property
+        for getting separate arrays of coordinate x and y values.::
+        
+          >>> x, y = patch.exterior.xy
+          >>> ax = asarray(x)
+          >>> ax
+          array([  1.00000000e+01,   9.95184727e+00,   9.80785280e+00,  ...])
+        
+        Numpy arrays can also be adapted to Shapely linestrings::
+        
+          >>> from shapely.geometry import asLineString
+          >>> asLineString(ag).length
+          62.806623139095073
+          >>> asLineString(ag).wkt
+          'LINESTRING (10.0000000000000000 0.0000000000000000, ...)'
+        
+        Testing
+        -------
+        
+        Shapely uses a Zope-stye suite of unittests and doctests, excercised via
+        setup.py.::
+        
+          $ python setup.py test
+        
+        Nosetests won't run the tests properly; Zope doctest suites are not currently
+        supported well by nose.
+        
+        Support
+        -------
+        
+        For current information about this project, see the wiki_.
+        
+        If you have questions, please consider joining our community list:
+        
+        http://trac.gispython.org/projects/PCL/wiki/CommunityList
+        
+        Credits
+        -------
+        
+        Shapely is written by:
+        
+        * Sean Gillies
+        * Aron Bierbaum
+        * Kai Lautaportti
+        
+        Patches contributed by:
+        
+        * Howard Butler
+        * Fr |eaigue| d |eaigue| ric Junod
+        * Eric Lemoine
+        * Jonathan Tartley
+        * Kristian Thy
+        * Oliver Tonnhofer
+        
+        Additional help from:
+        
+        * Justin Bronn (GeoDjango) for ctypes inspiration
+        * Martin Davis (JTS)
+        * Jaakko Salli for the Windows distributions
+        * Sandro Santilli, Mateusz Loskot, Paul Ramsey, et al (GEOS Project)
+        
+        Major portions of this work were supported by a grant (for Pleiades_) from the
+        U.S. National Endowment for the Humanities (http://www.neh.gov).
+        
+        .. _JTS: http://www.vividsolutions.com/jts/jtshome.htm
+        .. _PostGIS: http://postgis.org
+        .. _GEOS: http://trac.osgeo.org/geos/
+        .. _example apps: http://trac.gispython.org/lab/wiki/Examples
+        .. _wiki: http://trac.gispython.org/lab/wiki/Shapely
+        .. _manual: http://gispython.org/shapely/docs/1.2
+        .. |eaigue| unicode:: U+00E9
+           :trim:
+        .. _Pleiades: http://pleiades.stoa.org
+        
+Keywords: geometry topology gis
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: GIS

EGG-INFO/not-zip-safe

@@ -0,0 +1 @@
+

EGG-INFO/scripts/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')
+    

EGG-INFO/scripts/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/__init__.py

@@ -0,0 +1 @@
+# package

shapely/coords.py

@@ -0,0 +1,167 @@
+"""Coordinate sequence utilities
+"""
+
+from array import array
+from ctypes import string_at, byref, c_char_p, c_double, c_void_p
+from ctypes import c_int, c_size_t, c_uint
+import sys
+
+from shapely.geos import lgeos
+from shapely.topology import Validating
+
+
+class CoordinateSequence(object):
+    """
+    Iterative access to coordinate tuples from the parent geometry's coordinate
+    sequence.
+
+    Example:
+
+      >>> from shapely.wkt import loads
+      >>> g = loads('POINT (0.0 0.0)')
+      >>> list(g.coords)
+      [(0.0, 0.0)]
+
+    """
+
+    # Attributes
+    # ----------
+    # _cseq : c_void_p
+    #     Ctypes pointer to GEOS coordinate sequence
+    # _ndim : int
+    #     Number of dimensions (2 or 3, generally)
+    # __p__ : object
+    #     Parent (Shapely) geometry    
+    _cseq = None
+    _ndim = None
+    __p__ = None
+
+    def __init__(self, parent):
+        self.__p__ = parent
+
+    def _update(self):
+        self._ndim = self.__p__._ndim
+        self._cseq = lgeos.GEOSGeom_getCoordSeq(self.__p__._geom)
+    
+    def __len__(self):
+        self._update()
+        cs_len = c_uint(0)
+        lgeos.GEOSCoordSeq_getSize(self._cseq, byref(cs_len))
+        return cs_len.value
+
+    def __iter__(self):
+        self._update()
+        dx = c_double()
+        dy = c_double()
+        dz = c_double()
+        for i in range(self.__len__()):
+            lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(dx))
+            lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(dy))
+            if self._ndim == 3: # TODO: use hasz
+                lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(dz))
+                yield (dx.value, dy.value, dz.value)
+            else:
+                yield (dx.value, dy.value)
+
+    def __getitem__(self, i):
+        self._update()
+        M = self.__len__()
+        if i + M < 0 or i >= M:
+            raise IndexError("index out of range")
+        if i < 0:
+            ii = M + i
+        else:
+            ii = i
+        dx = c_double()
+        dy = c_double()
+        dz = c_double()
+        lgeos.GEOSCoordSeq_getX(self._cseq, ii, byref(dx))
+        lgeos.GEOSCoordSeq_getY(self._cseq, ii, byref(dy))
+        if self._ndim == 3: # TODO: use hasz
+            lgeos.GEOSCoordSeq_getZ(self._cseq, ii, byref(dz))
+            return (dx.value, dy.value, dz.value)
+        else:
+            return (dx.value, dy.value)
+
+    @property
+    def ctypes(self):
+        self._update()
+        n = self._ndim
+        m = self.__len__()
+        array_type = c_double * (m * n)
+        data = array_type()
+        temp = c_double()
+        for i in xrange(m):
+            lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(temp))
+            data[n*i] = temp.value
+            lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(temp))
+            data[n*i+1] = temp.value
+            if n == 3: # TODO: use hasz
+                lgeos.GEOSCoordSeq_getZ(self._cseq, i, byref(temp))
+                data[n*i+2] = temp.value
+        return data
+
+    def array_interface(self):
+        """Provide the Numpy array protocol."""
+        if sys.byteorder == 'little':
+            typestr = '<f8'
+        elif sys.byteorder == 'big':
+            typestr = '>f8'
+        else:
+            raise ValueError(
+                "Unsupported byteorder: neither little nor big-endian")
+        ai = {
+            'version': 3,
+            'typestr': typestr,
+            'data': self.ctypes,
+            }
+        ai.update({'shape': (len(self), self._ndim)})
+        return ai
+    
+    __array_interface__ = property(array_interface)
+    
+    @property
+    def xy(self):
+        """X and Y arrays"""
+        self._update()
+        m = self.__len__()
+        x = array('d')
+        y = array('d')
+        temp = c_double()
+        for i in xrange(m):
+            lgeos.GEOSCoordSeq_getX(self._cseq, i, byref(temp))
+            x.append(temp.value)
+            lgeos.GEOSCoordSeq_getY(self._cseq, i, byref(temp))
+            y.append(temp.value)
+        return x, y
+            
+
+class BoundsOp(Validating):
+
+    def __init__(self, *args):
+        pass
+
+    def __call__(self, this):
+        self._validate(this)
+        env = this.envelope
+        if env.geom_type == 'Point':
+            return env.bounds
+        cs = lgeos.GEOSGeom_getCoordSeq(env.exterior._geom)
+        cs_len = c_uint(0)
+        lgeos.GEOSCoordSeq_getSize(cs, byref(cs_len))
+        minx = 1.e+20
+        maxx = -1e+20
+        miny = 1.e+20
+        maxy = -1e+20
+        temp = c_double()
+        for i in xrange(cs_len.value):
+            lgeos.GEOSCoordSeq_getX(cs, i, byref(temp))
+            x = temp.value
+            if x < minx: minx = x
+            if x > maxx: maxx = x
+            lgeos.GEOSCoordSeq_getY(cs, i, byref(temp))
+            y = temp.value
+            if y < miny: miny = y
+            if y > maxy: maxy = y
+        return (minx, miny, maxx, maxy)
+