shapely 1.0b2__tar.gz → 1.0b3__tar.gz

{Shapely-1.0b2 → Shapely-1.0b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.0b2
+Version: 1.0b3
 Summary: Geospatial geometries, predicates, and operations
 Home-page: http://trac.gispython.org/projects/PCL/wiki/Shapely
 Author: Sean Gillies
@@ -23,7 +23,7 @@ Description: Shapely
         Dependencies
         ------------
         
-        * libgeos_c (2.2.3, also reported to work with 3.0 after small modifications.)
+        * libgeos_c (2.2.3, also reported to work with 3.0)
         * Python ctypes_ (standard in Python 2.5+)
         
         .. _ctypes: http://pypi.python.org/pypi/ctypes/
@@ -124,7 +124,7 @@ Description: Shapely
         For current information about this project, see the wiki_.
         
         .. _wiki: http://trac.gispython.org/projects/PCL/wiki/Shapely
-        .. _manual: http://trac.gispython.org/projects/PCL/wiki/ShapelyManual
+        .. _manual: http://gispython.org/shapely/manual.html
         
         If you have questions, please consider joining our community list:
         

{Shapely-1.0b2 → Shapely-1.0b3}/README.txt

@@ -15,7 +15,7 @@ http://zcologia.com/news/564/shapely-for-python-3-0/.)
 Dependencies
 ------------
 
-* libgeos_c (2.2.3, also reported to work with 3.0 after small modifications.)
+* libgeos_c (2.2.3, also reported to work with 3.0)
 * Python ctypes_ (standard in Python 2.5+)
 
 .. _ctypes: http://pypi.python.org/pypi/ctypes/
@@ -116,7 +116,7 @@ Support
 For current information about this project, see the wiki_.
 
 .. _wiki: http://trac.gispython.org/projects/PCL/wiki/Shapely
-.. _manual: http://trac.gispython.org/projects/PCL/wiki/ShapelyManual
+.. _manual: http://gispython.org/shapely/manual.html
 
 If you have questions, please consider joining our community list:
 

{Shapely-1.0b2 → Shapely-1.0b3}/Shapely.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.0b2
+Version: 1.0b3
 Summary: Geospatial geometries, predicates, and operations
 Home-page: http://trac.gispython.org/projects/PCL/wiki/Shapely
 Author: Sean Gillies
@@ -23,7 +23,7 @@ Description: Shapely
         Dependencies
         ------------
         
-        * libgeos_c (2.2.3, also reported to work with 3.0 after small modifications.)
+        * libgeos_c (2.2.3, also reported to work with 3.0)
         * Python ctypes_ (standard in Python 2.5+)
         
         .. _ctypes: http://pypi.python.org/pypi/ctypes/
@@ -124,7 +124,7 @@ Description: Shapely
         For current information about this project, see the wiki_.
         
         .. _wiki: http://trac.gispython.org/projects/PCL/wiki/Shapely
-        .. _manual: http://trac.gispython.org/projects/PCL/wiki/ShapelyManual
+        .. _manual: http://gispython.org/shapely/manual.html
         
         If you have questions, please consider joining our community list:
         

{Shapely-1.0b2 → Shapely-1.0b3}/Shapely.egg-info/SOURCES.txt

@@ -11,6 +11,8 @@ Shapely.egg-info/requires.txt
 Shapely.egg-info/top_level.txt
 examples/geoms.py
 examples/world.py
+manual/manual.txt
+manual/style.css
 shapely/__init__.py
 shapely/geos.py
 shapely/iterops.py

Shapely-1.0b3/manual/manual.txt

@@ -0,0 +1,773 @@
+==================
+The Shapely Manual
+==================
+
+:Author: Sean Gillies
+:address: sgillies@frii.com
+    http://zcologia.com/sgillies
+
+:revision: 1.0
+:date: 2 January 2008
+
+:copyright: This work is licensed under a `Creative Commons Attribution-Share Alike 3.0 United States License`__.
+
+.. __: http://creativecommons.org/licenses/by-sa/3.0/us/
+
+:abstract: This document describes the Shapely Python package for programming with geospatial geometries.
+
+.. sectnum::
+
+.. contents::
+
+Background
+==========
+
+Shapely is a Python package for programming with geospatial geometries. It is
+based on the GEOS_ library, a port of the `Java Topology Suite`_. Please refer
+to the JTS overview for definitions and illustrations of the various geometry
+types, operations, and predicates. See also the Shapely wiki_ and Python
+Package Index record_.
+
+.. _GEOS: http://geos.refractions.net
+.. _Java Topology Suite: http://www.jump-project.org/project.php?PID=JTS&SID=OVER
+.. _record: http://pypi.python.org/pypi/Shapely
+.. _wiki: http://trac.gispython.org/projects/PCL/wiki/Shapely
+
+Geometries
+==========
+
+The basic, standard GIS geometry model consists of single points, line strings,
+and polygons, homogeneous multi-point, multi-line string, and multi-polygon
+collections, and heterogeneous geometry collections. See the JTS illustration_.
+
+.. _illustration: http://www.jump-project.org/project.php?PID=JTS&SID=OVER#spatialdatatypes
+
+Shapely 1.0 does not provide circles, arcs, splines or the like.
+
+Factories
+---------
+
+Geometries can be created in the typical Python fashion, using the geometry
+classes themselves as factories.
+
+Pseudo-code blocks in this section will use the following notation. Let **a**
+be a Cartesian *x*, *y*, and optional *z* coordinate sequence. The coordinates
+values must be numeric types. Let (**a**\ 1, ..., **a**\ M) and (**b**\ 1, ...,
+**b**\ N) be ordered sequences of *M* and *N* such coordinate sequences,
+defining lines or rings.
+
+Points
+++++++
+
+The point factory *Point* takes a coordinate sequence parameter
+
+.. code-block:: python
+
+  >>> from shapely.geometry import Point
+  >>> point = Point(a)
+
+The alternate form is to pass individual coordinate parameters
+
+.. code-block:: python
+
+  >>> point = Point(x0, y0 [, z0])
+
+LineStrings
++++++++++++
+
+To create a line string, pass in an ordered sequence of coordinate sequences:
+
+.. code-block:: python
+
+  >>> from shapely.geometry import LineString
+  >>> line = LineString((a1, ..., aM))
+
+Polygons
+++++++++
+
+A polygon with only an exterior boundary and no holes is created by passing the sequence representation of a closed ring
+
+.. code-block:: python
+
+  >>> from shapely.geometry import Polygon
+  >>> polygon = Polygon((a1, ..., aM))
+
+If **a**\ 1 is not exactly equal to **a**\ M, the factory will close the ring.
+The following (unit square) polygons are therefore topologically equal
+
+.. code-block:: python
+
+  >>> polygon1 = Polygon(((0, 0), (0, 1), (1, 1), (1, 0), (0, 0)))
+  >>> polygon2 = Polygon(((0, 0), (0, 1), (1, 1), (1, 0)))
+  
+To create a polygon with interior boundaries pass a sequence of rings to the
+second parameter (*holes*)
+
+.. code-block:: python
+
+  >>> polygon = Polygon((a1, ..., aM), [(b1, ..., bN), ...])
+
+Rings *must* be non-crossing, ordered coordinate sequences. The order may be
+clockwise or counter-clockwise. The resulting topology is independent of the
+order.
+
+Multipart Geometry Factories
+----------------------------
+
+MultiPoints
++++++++++++
+
+An *N*\ -point geometry is created by passing an unordered sequence of
+coordinate sequences [**c**\ 1, ..., **c**\ N]
+
+.. code-block:: python
+
+  >>> from shapely.geometry import MultiPoint
+  >>> points = MultiPoint([c1, ..., cN])
+
+MultiLineStrings
+++++++++++++++++
+
+A multi-line geometry is created by passing a sequence of representations of
+lines
+
+.. code-block:: python
+
+  >>> from shapely.geometry import MultiLineString
+  >>> lines = MultiLineString([(a1, ..., aM), (b1, ..., bN), ...])
+
+MultiPolygons
++++++++++++++
+
+A multi-polygon geometry is created by passing a sequence of exterior ring and
+hole list tuples 
+
+.. code-block:: python
+
+  >>> from shapely.geometry import MultiPolygon
+  >>> lines = MultiPolygon([((a1, ..., aM), [(b1, ..., bN), ...]), ...])
+
+More explicit notation for the exterior and interior boundaries (or shells and
+holes) makes usage more clear
+
+.. code-block:: python
+
+  >>> shell = (a1, ..., aM)
+  >>> holes = [(b1, ..., bN), ...]
+  >>> lines = MultiPolygon([(shell, holes), ...])
+
+Constructive Spatial Analysis Methods
+-------------------------------------
+
+There are methods of geometry classes that also serve as factories for new
+geometries. It is important to note that these are topological and not
+point-wise operations, and therefore may produce results that are not what one
+might expect from operations on Python sets.
+
+See also the JTS |illustration2|_.
+
+.. |illustration2| replace:: illustration
+.. _illustration2: http://www.jump-project.org/project.php?PID=JTS&SID=OVER#spatialanalysismethods
+
+Example Geometries
+++++++++++++++++++
+
+.. code-block:: python
+
+  >>> 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)))
+
+Buffer
+++++++
+
+.buffer(width, quadsegs=16) : geometry
+  Returns a buffer region having the given width and with a specified number of
+  segments used to approximate curves.
+  
+The default result of buffering a point is an N-gon approximation of a circle:
+
+.. code-block:: python
+
+  >>> buffered = point_r.buffer(1.0)
+  >>> buffered
+  <shapely.geometry.polygon.Polygon object at ...>
+  >>> buffered.length
+  6.2806623139097271
+  >>> buffered.area
+  3.1365484905463727
+  >>> len(buffered.exterior.coords)
+  66
+
+Boundary
+++++++++
+
+.boundary : geometry
+  Returns a lower dimension geometry. The boundary of a polygon is a line, the
+  boundary of a line is a collection of points. The boundary of a point is an
+  empty (null) collection.
+
+.. code-block:: python
+
+  >>> polygon.boundary
+  <shapely.geometry.linestring.LineString object at ...>
+  >>> line_b.boundary
+  <shapely.geometry.multipoint.MultiPoint object at ...>
+  >>> point_r.boundary.is_empty
+  True
+
+Centroid
+++++++++
+
+.centroid : geometry
+  Returns the centroid, or geometric center of the polygon.
+
+.. code-block:: python
+
+  >>> centroid_point = polygon.centroid
+  >>> centroid_point.wkt
+  'POINT (-0.0000000000000000 -0.0000000000000000)'
+
+
+Convex Hull
++++++++++++
+
+.convex_hull : geometry
+  Imagine an elastic band stretched around the geometry: that's a convex hull,
+  more or less.
+
+For example, collect the three points into a multi-point geometry, and get the
+triangular polygon that is their convex hull:
+
+.. code-block:: python
+
+  >>> multi_point = point_r.union(point_g)
+  >>> multi_point = multi_point.union(point_b)
+  >>> multi_point.convex_hull
+  <shapely.geometry.polygon.Polygon object at ...>
+
+Difference
+++++++++++
+
+.difference(other) : geometry
+  Returns a geometry representing the points making up this geometry that do
+  not make up *other*. Note that A.difference(B) is not necessarily equal to
+  B.difference(A).
+
+.. code-block:: python
+
+  >>> hull = multi_point.convex_hull
+  >>> polygon.difference(hull)
+  <shapely.geometry.polygon.Polygon object at ...>
+
+Intersection
+++++++++++++
+
+.intersection(other) : geometry
+  Returns the intersection of one geometry and the *other* geometry.
+
+.. code-block:: python
+
+  >>> polygon.intersection(hull)
+  <shapely.geometry.polygon.Polygon object at ...>
+
+Symmetric Difference
+++++++++++++++++++++
+
+.symmetric_difference(other) : geometry
+  Returns a geometry combining the points in this geometry not in *other*, and
+  the points in *other* not in this geometry.
+
+.. code-block:: python
+
+  >>> polygon.symmetric_difference(hull)
+  <shapely.geometry.multipolygon.MultiPolygon object at ...>
+
+Union
++++++
+
+.union(other) : geometry
+  Returns the union of one geometry and the *other* geometry.
+
+Point unions were demonstrated above under convex hull. The union of polygons
+will be a polygon or a multi-polygon depending on whether they intersect or
+not:
+
+.. code-block:: python
+
+  >>> hull.union(polygon)
+  <shapely.geometry.polygon.Polygon object at ...>
+
+Unary Spatial Predicates
+------------------------
+
+These are implemented as Python attributes.
+
+Is Empty
+++++++++
+
+.is_empty : bool
+  True if the set of points in this geometry is empty, else False. For more
+  details, see
+  http://geos.refractions.net/ro/doxygen_docs/html/classgeos_1_1geom_1_1Geometry.html#a17.  
+
+Is Valid
+++++++++
+
+.is_valid : bool
+  True if the geometry is valid (definition depends on sub-class), else False.
+  For more details, see
+  http://geos.refractions.net/ro/doxygen_docs/html/classgeos_1_1geom_1_1Geometry.html#a16.
+
+Is Ring
++++++++
+
+.is_ring : bool
+  True if the geometry is a closed ring, else False.
+
+Has Z
++++++
+
+.has_z : bool
+  True if the geometry's coordinate sequence(s) have z values (are
+  3-dimensional)
+
+Examples
+++++++++
+
+.. code-block:: python
+
+  >>> polygon.is_empty
+  False
+  >>> polygon.is_valid
+  True
+  >>> polygon.is_ring
+  False
+  >>> polygon.boundary.is_ring
+  True
+  >>> polygon.has_z
+  True
+
+(Note: that last return value exposes a bug in GEOS 2.2.3. Should be False.)
+
+Binary Spatial Predicates
+-------------------------
+
+All of these methods take a single positional argument, an *other* geometry. It
+is important to note that these are topological and not point-wise operations,
+and therefore may produce results that are not what one might expect from
+operations on Python.
+
+Contains
+++++++++
+
+.contains(other) : bool
+  True if the geometry is spatially within, without touching. Applies to all
+  types of geometries.
+
+.. code-block:: python
+
+  >>> polygon.contains(point_b)
+  True
+
+Crosses
++++++++
+
+.crosses(other) : bool
+  Only linear geometries (lines, rings, polygon boundaries) may ever cross. No
+  geometry may ever cross a point.
+
+.. code-block:: python
+
+  >>> line_b.crosses(polygon)
+  True
+
+Disjoint
+++++++++
+
+.disjoint(other) : bool
+  True if geometries do not spatially relate in any way, else False. See the
+  complementary *intersects*. 
+
+.. code-block:: python
+
+  >>> polygon.disjoint(point_r)
+  True
+
+Equals
+++++++
+
+.equals(other) : bool
+  Two geometries are topologically equal if their interiors intersect and no
+  part of the interior or boundary of one geometry intersects the exterior of
+  the other. Not to be confused with Python's *__equals__*.
+
+Intersects
+++++++++++
+
+.intersects(other) : bool
+  This predicate is the complement of *disjoint*: geometries that do not
+  intersect are disjoint. Intersects is the most inclusive predicate.
+
+.. code-block:: python
+
+  >>> polygon.intersects(point_b)
+  True
+
+Touches
++++++++
+
+.touches(other) : bool
+  True if geometries *only* touch. The least inclusive predicate.
+
+.. code-block:: python
+
+  >>> polygon.touches(line_g)
+  True
+  >>> polygon.touches(line_b)
+  False
+
+Within
+++++++
+
+.within(other): bool
+  The inverse of *contains*.
+
+General Methods
+---------------
+
+Distance
+++++++++
+
+.distance(other) : geometry
+  The minimum distance from one geometry to the other.
+
+.. code-block:: python
+
+  >>> Point(0,0).distance(Point(1,1))
+  1.4142135623730951
+
+
+Scalar Properties
+-----------------
+
+Area
+++++
+
+.area : float
+  Area of the geometry, unitless. Non-zero only for surfaces (polygons,
+  multi-polygons).
+
+Length
+++++++
+
+.length : float
+  Length of the geometry, unitless. Non-zero only for linear geometries
+  (line strings, rings, polygon boundaries)
+
+Examples
+++++++++
+
+.. code-block:: python
+
+  >>> polygon.area
+  4.0
+  >>> polygon.length
+  8.0
+  >>> line_r.length
+  1.0
+  >>> line_b.length
+  3.9812058474788765
+
+Geometry Parts and Coordinates
+==============================
+
+Coordinate Sequences
+--------------------
+
+The coordinates of points, line strings, and polygon rings can be accessed
+through the *coords* attribute of a geometry. *Coords* is an iterator over
+coordinate tuples.
+
+.. code-block:: python
+
+  >>> point_r.coords
+  <shapely.geometry.base.CoordinateSequence object at ...>
+  >>> len(point_r.coords)
+  1
+  >>> point_r.coords[0]
+  (-1.5, 1.2)
+  >>> list(point_r.coords)
+  [(-1.5, 1.2)]
+
+The coordinate sequence can be modifed by assigning a sequence (**a**\ 1, ...,
+**a**\ M) to the coords attribute.
+
+.. code-block:: python
+
+  >>> point_new = Point(0, 0)
+  >>> point_new.coords = (1, 1)
+  >>> list(point_new.coords)
+  [(1.0, 1.0)]
+
+For line strings:
+
+.. code-block:: python
+
+  >>> line_new = LineString([(0,0), (1,1)])
+  >>> line_new.coords = [(1,1), (2,2)]
+  >>> list(line_new.coords)
+  [(1.0, 1.0), (2.0, 2.0)]
+
+Polygon Rings
+-------------
+
+The exterior boundary of a polygon can be accessed through the *exterior*
+attribute of the geometry object.
+
+.. code-block:: python
+
+  >>> polygon.exterior
+  <shapely.geometry.polygon.LinearRing object at ...>
+  >>> list(polygon.exterior.coords)
+  [(-1.0, -1.0), (-1.0, 1.0), (1.0, 1.0), (1.0, -1.0), (-1.0, -1.0)]
+
+The interior boundaries (or holes) of a polygon can be accessed through the
+*interiors* attribute, which is a list of rings.
+
+Sub-geometries
+--------------
+
+The parts of a multi-part geometry can be accessed through the *geoms*
+attribute of the geometry object, which is an iterator over the sub-geometries:
+
+.. code-block:: python
+
+  >>> multi_point.geoms
+  <shapely.geometry.base.GeometrySequence object at ...>
+  >>> len(multi_point.geoms)
+  3
+  >>> from pprint import pprint
+  >>> pprint(list(multi_point.geoms))
+  [<shapely.geometry.point.Point object at ...>,
+   <shapely.geometry.point.Point object at ...>,
+   <shapely.geometry.point.Point object at ...>]
+
+The coordinate sequences of these sub-geometries can then be accessed as
+described above.
+
+Interoperation
+==============
+
+Shapely provides 4 avenues for interoperation with other Python and GIS
+software.
+
+Well-known Formats
+------------------
+
+Well-known Text (WKT)
++++++++++++++++++++++
+
+The WKT representation of any geometry object can be had via the **wkt**
+attribute:
+
+.. code-block:: python
+
+  >>> point_r.wkt
+  'POINT (-1.5000000000000000 1.2000000000000000)'
+
+Hex-encode that string and you have a value that can be conveniently inserted directly into PostGIS
+
+.. code-block:: python
+
+  >>> point_r.wkt.encode('hex')
+  '504f494e5420282d312e3530303030303030303030303030303020312e3230303030303030303030303030303029'
+
+New geometries can be created from WKT representations using the
+*shapely.wkt.loads* factory (inspired by the *pickle* module) 
+
+.. code-block:: python
+
+  >>> from shapely.wkt import loads
+  >>> loads('POINT (0 0)')
+  <shapely.geometry.point.Point object at ...>
+
+Well-known Binary (WKB)
++++++++++++++++++++++++
+
+The WKB representation of any geometry object can be had via the **wkb**
+attribute. New geometries can be created from WKB data using the
+*shapely.wkb.loads* factory. Use this format to interoperate with ogr.py:
+
+.. code-block:: python
+
+  >>> import ogr
+  >>> from shapely.wkb import loads
+  >>> source = ogr.Open("/tmp/world_borders.shp")
+  >>> borders = source.GetLayerByName("world_borders")
+  >>> feature = borders.GetNextFeature()
+  >>> loads(feature.GetGeometryRef().ExportToWkb())
+  <shapely.geometry.polygon.Polygon object at ...>
+
+Python Sequences
+----------------
+
+Python sequence data can be analyzed as Shapely geometries using the
+*shapely.geometry.as\** adapters while leaving the data in its original
+storage. A pair of float can be treated as a point with **asPoint**:
+
+.. code-block:: python
+
+  >>> from shapely.geometry import asPoint
+  >>> coords = [3.0, 4.0]
+  >>> pa = asPoint(coords)
+  >>> pa.wkt
+  'POINT (3.0000000000000000 4.0000000000000000)'
+
+Move the coordinates and watch the geometry adapter change
+
+.. code-block:: python
+
+  >>> coords[0] = 1.0
+  >>> pa.wkt
+  'POINT (1.0000000000000000 4.0000000000000000)'
+
+The **asLineString** adapter works much the same. The **asPolygon** adapter is
+used like
+
+.. code-block:: python
+
+  >>> from shapely.geometry import asPolygon
+  >>> coords = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]]
+  >>> hole_coords = [((0.1,0.1), (0.1,0.2), (0.2,0.2), (0.2,0.1))]
+  >>> pa = asPolygon(coords, hole_coords)
+  >>> len(pa.exterior.coords)
+  5
+  >>> len(pa.interiors)
+  1
+  >>> len(pa.interiors[0].coords)
+  5
+
+Numpy Array Interface
+---------------------
+
+Shapely geometries provide the Numpy array interface which means that points,
+line strings, and polygon rings can be used as Numpy arrays:
+
+.. code-block:: python
+
+  >>> from numpy import array
+  >>> a = array(polygon.exterior)
+  >>> a
+  array([[-1., -1.],
+         [-1.,  1.],
+         [ 1.,  1.],
+         [ 1., -1.],
+         [-1., -1.]])
+
+The *numpy.asarray* function does not copy coordinate values at the price of
+slower numpy access to coordinates.
+
+The *shapely.geometry.as\** functions can also be used to wrap numpy arrays,
+which can then be analyzed using Shapely while maintaining their original
+storage. A 1 x 2 array can be adapted to a point
+
+.. code-block:: python
+
+  >>> a = array([1.0, 2.0])
+  >>> pa = asPoint(a)
+  >>> pa.wkt
+  'POINT (1.0000000000000000 2.0000000000000000)'
+
+and a N x 2 array can be adapted to a line string
+
+.. code-block:: python
+
+  >>> from shapely.geometry import asLineString
+  >>> a = array([[1.0, 2.0], [3.0, 4.0]])
+  >>> la = asLineString(a)
+  >>> la.wkt
+  'LINESTRING (1.0000000000000000 2.0000000000000000, 3.0000000000000000 4.0000000000000000)'
+
+There is no Numpy array representation of a polygon.
+
+Python Geo Interface
+--------------------
+
+Any object that provides the GeoJSON-like `Python geo interface`_ can be
+adapted and used as a Shapely geometry using the *shapely.geometry.asShape*
+function. For example, a dictionary:
+
+.. code-block:: python
+
+  >>> from shapely.geometry import asShape
+  >>> d = {"type": "Point", "coordinates": (0.0, 0.0)}
+  >>> shape = asShape(d)
+  >>> shape.geom_type
+  'Point'
+  >>> list(shape.coords)
+  [(0.0, 0.0)]
+
+Or a simple placemark-type object:
+
+.. code-block:: python
+
+  >>> class GeoThing(object):
+  ...     def __init__(self, d):
+  ...         self.__geo_interface__ = d
+  >>> thing = GeoThing({"type": "Point", "coordinates": (0.0, 0.0)})
+  >>> shape = asShape(thing)
+  >>> shape.geom_type
+  'Point'
+  >>> list(shape.coords)
+  [(0.0, 0.0)]
+
+.. _Python geo interface: http://trac.gispython.org/projects/PCL/wiki/PythonGeoInterface
+
+Advanced Features
+=================
+
+Iterative Operations
+--------------------
+
+Shapely provides functions for efficient operations on large sets of
+geometries.
+
+Contains
+++++++++
+
+To find the subset of points that are contained within a polygon, use
+*shapely.iterops.contains*:
+
+.. code-block:: python
+
+  >>> from shapely.geometry import Polygon
+  >>> from shapely.geometry import Point
+  >>> coords = ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0), (0.0, 0.0))
+  >>> polygon = Polygon(coords)
+  >>> points = [Point(0.5, 0.5), Point(2.0, 2.0)]  
+  >>> from shapely import iterops  
+  >>> list(iterops.contains(polygon, points, True))
+  [<shapely.geometry.point.Point object at ...>]
+
+The second parameter to *iterops.contains* can be any kind of iterator, even a
+generator of objects. If it yields tuples, then the second element of the tuple
+will be ultimately yielded from *iterops.contains*.
+
+.. code-block:: python
+
+  >>> list(iterops.contains(polygon, iter((p, p.wkt) for p in points)))
+  ['POINT (0.5000000000000000 0.5000000000000000)']
+
+Credits
+=======
+
+Shapely is written by Sean Gillies with contributions from Howard Butler, Kai
+Lautaportti (Hexagon IT), Frédéric Junod (Camptocamp SA), Eric Lemoine
+(Camptocamp SA) and ctypes tips from Justin Bronn (GeoDjango).
+
+

Shapely-1.0b3/manual/style.css

@@ -0,0 +1,231 @@
+/* css */
+
+body {
+  font: 90% 'Lucida Grande', Verdana, Geneva, Lucida, Arial, Helvetica, sans-serif;
+  background: #ffffff;
+  color: black;
+  margin: 2em;
+  padding: 2em;
+}
+
+a[href] {
+  color: #436976;
+  background-color: transparent;
+}
+
+a.toc-backref {
+  text-decoration: none;
+}
+
+h1 a[href] {
+  text-decoration: none;
+  color: #fcb100;
+  background-color: transparent;
+}
+
+a.strong {
+  font-weight: bold;
+}
+
+img {
+  margin: 0;
+  border: 0;
+}
+
+p {
+  margin: 0.5em 0 1em 0;
+  line-height: 1.5em;
+}
+p a {
+  text-decoration: underline;
+}
+p a:visited {
+  color: purple;
+  background-color: transparent;
+}
+p a:active {
+  color: red;
+  background-color: transparent;
+}
+a:hover {
+  text-decoration: none;
+}
+p img {
+  border: 0;
+  margin: 0;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  color: #003a6b;
+  background-color: transparent;
+  font: 100% 'Lucida Grande', Verdana, Geneva, Lucida, Arial, Helvetica, sans-serif;
+  margin: 0;
+  padding-top: 0.5em;
+}
+
+h1 {
+  font-size: 160%;
+  margin-bottom: 0.5em;
+  border-bottom: 1px solid #fcb100;
+}
+h2 {
+  font-size: 140%;
+  margin-bottom: 0.5em;
+  border-bottom: 1px solid #aaa;
+}
+h3 {
+  font-size: 130%;
+  margin-bottom: 0.5em;
+  text-decoration: underline;
+}
+h4 {
+  font-size: 110%;
+  font-weight: bold;
+}
+h5 {
+  font-size: 100%;
+  font-weight: bold;
+}
+h6 {
+  font-size: 80%;
+  font-weight: bold;
+}
+
+ul a, ol a {
+  text-decoration: underline;
+}
+
+dt {
+  font-weight: bold;
+}
+dt a {
+  text-decoration: none;
+}
+
+dd {
+  line-height: 1.5em;
+  margin-bottom: 1em;
+}
+
+legend {
+  background: #ffffff;
+  padding: 0.5em;
+}
+
+form {
+  margin: 0;
+}
+
+
+dl.form {
+  margin: 0;
+  padding: 1em;
+}
+
+dl.form dt {
+  width: 30%;
+  float: left;
+  margin: 0;
+  padding: 0 0.5em 0.5em 0;
+  text-align: right;
+}
+
+input {
+  font: 100% 'Lucida Grande', Verdana, Geneva, Lucida, Arial, Helvetica, sans-serif;
+  color: black;
+  background-color: white;
+  vertical-align: middle;
+}
+
+abbr, acronym, .explain {
+  color: black;
+  background-color: transparent;
+}
+
+q, blockquote {
+}
+
+code, pre {
+  font-family: monospace;
+  font-size: 1.2em;
+  display: block;
+  padding: 10px;
+  border: 1px solid #838183;
+  background-color: #eee;
+  color: #000;
+  overflow: auto;
+  margin: 0.5em 1em;
+}
+
+tt.docutils {
+  background-color: #eeeeee;
+}
+
+.docinfo {
+  text-align: left;
+}
+
+div.highlight {
+  margin-left: 2em ;
+  margin-right: 2em ;
+  background-color: #eeeeee
+  }
+
+.c { color: #008800; font-style: italic } /* Comment */
+.err { border: 1px solid #FF0000 } /* Error */
+.k { color: #AA22FF; font-weight: bold } /* Keyword */
+.o { color: #666666 } /* Operator */
+.cm { color: #008800; font-style: italic } /* Comment.Multiline */
+.cp { color: #008800 } /* Comment.Preproc */
+.c1 { color: #008800; font-style: italic } /* Comment.Single */
+.gd { color: #A00000 } /* Generic.Deleted */
+.ge { font-style: italic } /* Generic.Emph */
+.gr { color: #FF0000 } /* Generic.Error */
+.gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.gi { color: #00A000 } /* Generic.Inserted */
+.go { color: #808080 } /* Generic.Output */
+.gp { color: #000080; font-weight: bold } /* Generic.Prompt */
+.gs { font-weight: bold } /* Generic.Strong */
+.gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.gt { color: #0040D0 } /* Generic.Traceback */
+.kc { color: #AA22FF; font-weight: bold } /* Keyword.Constant */
+.kd { color: #AA22FF; font-weight: bold } /* Keyword.Declaration */
+.kp { color: #AA22FF } /* Keyword.Pseudo */
+.kr { color: #AA22FF; font-weight: bold } /* Keyword.Reserved */
+.kt { color: #AA22FF; font-weight: bold } /* Keyword.Type */
+.m { color: #666666 } /* Literal.Number */
+.s { color: #BB4444 } /* Literal.String */
+.na { color: #BB4444 } /* Name.Attribute */
+.nb { color: #AA22FF } /* Name.Builtin */
+.nc { color: #0000FF } /* Name.Class */
+.no { color: #880000 } /* Name.Constant */
+.nd { color: #AA22FF } /* Name.Decorator */
+.ni { color: #999999; font-weight: bold } /* Name.Entity */
+.ne { color: #D2413A; font-weight: bold } /* Name.Exception */
+.nf { color: #00A000 } /* Name.Function */
+.nl { color: #A0A000 } /* Name.Label */
+.nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
+.nt { color: #008000; font-weight: bold } /* Name.Tag */
+.nv { color: #B8860B } /* Name.Variable */
+.ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
+.mf { color: #666666 } /* Literal.Number.Float */
+.mh { color: #666666 } /* Literal.Number.Hex */
+.mi { color: #666666 } /* Literal.Number.Integer */
+.mo { color: #666666 } /* Literal.Number.Oct */
+.sb { color: #BB4444 } /* Literal.String.Backtick */
+.sc { color: #BB4444 } /* Literal.String.Char */
+.sd { color: #BB4444; font-style: italic } /* Literal.String.Doc */
+.s2 { color: #BB4444 } /* Literal.String.Double */
+.se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
+.sh { color: #BB4444 } /* Literal.String.Heredoc */
+.si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */
+.sx { color: #008000 } /* Literal.String.Other */
+.sr { color: #BB6688 } /* Literal.String.Regex */
+.s1 { color: #BB4444 } /* Literal.String.Single */
+.ss { color: #B8860B } /* Literal.String.Symbol */
+.bp { color: #AA22FF } /* Name.Builtin.Pseudo */
+.vc { color: #B8860B } /* Name.Variable.Class */
+.vg { color: #B8860B } /* Name.Variable.Global */
+.vi { color: #B8860B } /* Name.Variable.Instance */
+.il { color: #666666 } /* Literal.Number.Integer.Long */
+

{Shapely-1.0b2 → Shapely-1.0b3}/setup.py

@@ -1,11 +1,17 @@
 
 from setuptools import setup, Extension
+from sys import version_info
+
+# Require ctypes egg only for Python < 2.5
+install_requires = ['setuptools']
+if version_info[:2] < (2,5):
+    install_requires.append('ctypes')
 
 # Get text from README.txt
 readme_text = file('README.txt', 'rb').read()
 
 setup(name          = 'Shapely',
-      version       = '1.0b2',
+      version       = '1.0b3',
       description   = 'Geospatial geometries, predicates, and operations',
       license       = 'BSD',
       keywords      = 'geometry topology',
@@ -16,7 +22,7 @@ setup(name          = 'Shapely',
       url   = 'http://trac.gispython.org/projects/PCL/wiki/Shapely',
       long_description = readme_text,
       packages      = ['shapely', 'shapely.geometry'],
-      install_requires = ['setuptools', 'ctypes'],
+      install_requires = install_requires,
       #tests_require = ['numpy'], -- not working with "tests" command
       test_suite = 'tests.test_suite',
       classifiers   = [

{Shapely-1.0b2 → Shapely-1.0b3}/shapely/geometry/polygon.py

@@ -399,7 +399,7 @@ class PolygonAdapter(Polygon):
         return geos_polygon_from_py(self.shell, self.holes)[0]       
 
 
-def asPolygon(shell, holes):
+def asPolygon(shell, holes=None):
     """Factory for PolygonAdapter instances."""
     return PolygonAdapter(shell, holes)