shapely 1.2.13__py2.6-win-amd64.egg → 1.2.18__py2.6-win-amd64.egg

shapely/tests/Persist.txt

@@ -0,0 +1,35 @@
+Persistence tests
+=================
+
+Pickle
+------
+
+  >>> from shapely.geometry import Point
+  >>> import pickle
+  >>> p = Point(0.0, 0.0)
+  >>> data = pickle.dumps(p)
+  >>> q = pickle.loads(data)
+  >>> q.equals(p)
+  True
+
+WKB
+---
+
+  >>> from shapely import wkb
+  >>> bytes = wkb.dumps(p)
+  >>> pb = wkb.loads(bytes)
+  >>> pb.equals(p)
+  True
+
+WKT
+---
+
+  >>> from shapely import wkt
+  >>> text = wkt.dumps(p)
+  >>> text
+  'POINT (0.0000000000000000 0.0000000000000000)'
+  >>> pt = wkt.loads(text)
+  >>> pt.equals(p)
+  True
+
+

shapely/tests/Point.txt

@@ -0,0 +1,148 @@
+Testing Point
+=============
+
+  >>> from shapely.geometry import Point
+
+Test 2D points
+
+  >>> p = Point(0.0, 0.0)
+  >>> str(p)
+  'POINT (0.0000000000000000 0.0000000000000000)'
+  >>> p.wkt
+  'POINT (0.0000000000000000 0.0000000000000000)'
+    
+Check 3D
+
+  >>> p = Point(0.0, 0.0, 1.0)
+  >>> p.z
+  1.0
+  >>> str(p)
+  'POINT (0.0000000000000000 0.0000000000000000)'
+  >>> p.wkt
+  'POINT (0.0000000000000000 0.0000000000000000)'
+
+Construct from a numpy array
+
+  >>> from numpy import array
+  >>> p = Point(array([1.0, 2.0]))
+  >>> p.wkt
+  'POINT (1.0000000000000000 2.0000000000000000)'
+
+From coordinate sequence
+
+  >>> p = Point((3.0, 4.0))
+  >>> p.wkt
+  'POINT (3.0000000000000000 4.0000000000000000)'
+
+From another point
+
+  >>> q = Point(p)
+  >>> print p.wkt
+  POINT (3.0000000000000000 4.0000000000000000)
+
+Coordinate access
+-----------------
+
+  >>> p.x
+  3.0
+  >>> p.y
+  4.0
+
+  >>> tuple(p.coords)
+  ((3.0, 4.0),)
+
+  >>> p.coords[0]
+  (3.0, 4.0)
+  >>> p.coords[1] # doctest: +ELLIPSIS
+  Traceback (most recent call last):
+  ...
+  IndexError: index out of range
+
+Bounds
+------
+
+  >>> p.bounds
+  (3.0, 4.0, 3.0, 4.0)
+
+Geo interface
+-------------
+
+  >>> p.__geo_interface__
+  {'type': 'Point', 'coordinates': (3.0, 4.0)}
+
+
+Modify coordinates
+------------------
+
+  >>> p.coords = (0.0, 0.0)
+  >>> p.__geo_interface__
+  {'type': 'Point', 'coordinates': (0.0, 0.0)}
+
+Alternate method
+
+  >>> p.coords = ((0.0, 0.0),)
+  >>> p.__geo_interface__
+  {'type': 'Point', 'coordinates': (0.0, 0.0)}
+
+Adapter
+-------
+
+  >>> from shapely.geometry import asPoint
+
+  Adapt a Numpy array to a point
+
+  >>> a = array([1.0, 2.0])
+  >>> pa = asPoint(a)
+  >>> pa.context
+  array([ 1.,  2.])
+  >>> pa.wkt
+  'POINT (1.0000000000000000 2.0000000000000000)'
+
+  Now, the inverse
+
+  >>> pa.__array_interface__ == pa.context.__array_interface__
+  True
+  >>> from numpy import asarray
+  >>> pas = asarray(pa)
+  >>> pas
+  array([ 1.,  2.])
+
+  Adapt a coordinate list to a point
+
+  >>> coords = [3.0, 4.0]
+  >>> pa = asPoint(coords)
+  >>> pa.wkt
+  'POINT (3.0000000000000000 4.0000000000000000)'
+  >>> pa.distance(p)
+  5.0
+  
+  Move the coordinates and watch the distance change
+
+  >>> coords[0] = 1.0
+  >>> pa.wkt
+  'POINT (1.0000000000000000 4.0000000000000000)'
+  >>> '%.10f' % pa.distance(p)
+  '4.1231056256'
+
+  Now, the inverse
+  
+  >>> ai = pa.__array_interface__
+  >>> pas = asarray(pa)
+  >>> pas
+  array([ 1.,  4.])
+
+Test Non-operability of Null geometry
+
+  >>> p_null = Point()
+  >>> p_null.wkt # doctest: +ELLIPSIS
+  'GEOMETRYCOLLECTION EMPTY'
+
+  >>> p_null.area # doctest: +ELLIPSIS
+  0.0
+
+Check that we can set coordinates of a null geometry
+
+  >>> p_null.coords = (0, 0)
+  >>> p_null.wkt
+  'POINT (0.0000000000000000 0.0000000000000000)'
+

shapely/tests/Polygon.txt

@@ -0,0 +1,143 @@
+Polygons and Linear Rings
+=========================
+
+Initialization
+--------------
+
+  Linear rings won't usually be created by users, but by polygons
+
+  >>> coords = ((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0))
+  >>> from shapely.geometry.polygon import LinearRing
+  >>> ring = LinearRing(coords)
+  >>> len(ring.coords)
+  5
+  >>> ring.coords[0] == ring.coords[4]
+  True
+  >>> ring.coords[0] == ring.coords[-1]
+  True
+  >>> ring.is_ring
+  True
+
+  Coordinate modification
+  -----------------------
+
+  >>> ring.coords = ((0.0, 0.0), (0.0, 2.0), (2.0, 2.0), (2.0, 0.0))
+  >>> ring.__geo_interface__
+  {'type': 'LinearRing', 'coordinates': ((0.0, 0.0), (0.0, 2.0), (2.0, 2.0), (2.0, 0.0), (0.0, 0.0))}
+
+  Test ring adapter
+
+  >>> coords = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]]
+  >>> from shapely.geometry.polygon import asLinearRing
+  >>> ra = asLinearRing(coords)
+  >>> ra.wkt
+  'LINEARRING (0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 1.0000000000000000 0.0000000000000000, 0.0000000000000000 0.0000000000000000)'
+  >>> coords[3] = [2.0, -1.0]
+  >>> ra.wkt
+  'LINEARRING (0.0000000000000000 0.0000000000000000, 0.0000000000000000 1.0000000000000000, 1.0000000000000000 1.0000000000000000, 2.0000000000000000 -1.0000000000000000, 0.0000000000000000 0.0000000000000000)'
+
+  Construct a polygon, exterior ring only
+
+  >>> from shapely.geometry import Polygon
+  >>> polygon = Polygon(coords)
+  >>> len(polygon.exterior.coords)
+  5
+  
+Ring Access
+-----------
+
+  >>> polygon.exterior # doctest: +ELLIPSIS
+  <shapely.geometry.polygon.LinearRing object at ...>
+  >>> ring = polygon.exterior
+  >>> len(ring.coords)
+  5
+  >>> ring.coords[0] == ring.coords[4] == (0., 0.)
+  True
+  >>> ring.is_ring
+  True
+  >>> len(polygon.interiors)
+  0
+
+  Create a new polygon from WKB
+
+  >>> data = polygon.wkb
+  >>> polygon = None
+  >>> ring = None
+  >>> from shapely.wkb import loads
+  >>> polygon = loads(data)
+  >>> ring = polygon.exterior
+  >>> len(ring.coords)
+  5
+  >>> ring.coords[0] == ring.coords[4] == (0., 0.)
+  True
+  >>> ring.is_ring
+  True
+  >>> polygon = None
+
+Interior rings (holes)
+----------------------
+
+  >>> polygon = Polygon(coords, [((0.25,0.25), (0.25,0.5), (0.5,0.5), (0.5,0.25))])
+  >>> len(polygon.exterior.coords)
+  5
+  >>> len(polygon.interiors[0].coords)
+  5
+  >>> polygon.interiors[1] # doctest: +ELLIPSIS
+  Traceback (most recent call last):
+  ...
+  IndexError: index out of range
+
+Coordinate getters and setters raise exceptions
+
+  >>> polygon._get_coords()
+  Traceback (most recent call last):
+  ...
+  NotImplementedError: Component rings have coordinate sequences, but the polygon does not
+  >>> polygon.coords
+  Traceback (most recent call last):
+  ...
+  NotImplementedError: Component rings have coordinate sequences, but the polygon does not
+
+
+Geo interface
+-------------
+
+  >>> polygon.__geo_interface__
+  {'type': 'Polygon', 'coordinates': (((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (2.0, -1.0), (0.0, 0.0)), ((0.25, 0.25), (0.25, 0.5), (0.5, 0.5), (0.5, 0.25), (0.25, 0.25)))}
+
+
+Adapter
+-------
+
+  >>> hole_coords = [((0.25,0.25), (0.25,0.5), (0.5,0.5), (0.5,0.25))]
+  >>> from shapely.geometry import asPolygon
+  >>> pa = asPolygon(coords, hole_coords)
+  >>> len(pa.exterior.coords)
+  5
+  >>> len(pa.interiors)
+  1
+  >>> len(pa.interiors[0].coords)
+  5
+
+Test Non-operability of Null rings
+
+  >>> r_null = LinearRing()
+  >>> r_null.wkt # doctest: +ELLIPSIS
+  'GEOMETRYCOLLECTION EMPTY'
+
+  >>> r_null.length
+  0.0
+
+Check that we can set coordinates of a null geometry
+
+  >>> r_null.coords = [(0, 0), (1, 1), (1, 0)]
+  >>> print r_null.length # doctest: +ELLIPSIS
+  3.414...
+
+Error handling
+--------------
+
+  >>> p = Polygon([[1,2], [2, 3]])
+  Traceback (most recent call last):
+  ...
+  ValueError: A LinearRing must have at least 3 coordinate tuples

shapely/tests/Predicates.txt

@@ -0,0 +1,51 @@
+Test GEOS predicates
+====================
+
+  >>> from shapely.geometry import Point
+  >>> point = Point(0.0, 0.0)
+
+Binary Predicates
+-----------------
+
+  >>> point.disjoint(Point(-1.0, -1.0))
+  True
+
+  >>> point.touches(Point(-1.0, -1.0))
+  False
+
+  >>> point.crosses(Point(-1.0, -1.0))
+  False
+
+  >>> point.within(Point(-1.0, -1.0))
+  False
+
+  >>> point.contains(Point(-1.0, -1.0))
+  False
+
+  >>> point.overlaps(Point(-1.0, -1.0))
+  False
+
+  >>> point.equals(Point(-1.0, -1.0))
+  False
+
+  >>> point.equals(Point(0.0, 0.0))
+  True
+
+Unary Predicates
+----------------
+
+  >>> point.is_empty
+  False
+
+  >>> point.is_valid
+  True
+  
+  >>> point.is_simple
+  True
+
+  >>> point.is_ring
+  False
+
+  >>> point.has_z
+  False
+

shapely/tests/__init__.py

@@ -3,7 +3,9 @@ from unittest import TestSuite
 import test_doctests, test_prepared, test_equality, test_geomseq, test_xy
 import test_collection, test_emptiness, test_singularity, test_validation
 import test_mapping, test_delegated, test_dlls, test_linear_referencing
-import test_products_z, test_box, test_speedups, test_cga
+import test_products_z, test_box, test_speedups, test_cga, test_getitem
+import test_ndarrays, test_unary_union, test_pickle, test_affinity
+import test_transform, test_styles
 
 def test_suite():
     suite = TestSuite()
@@ -24,5 +26,12 @@ def test_suite():
     suite.addTest(test_box.test_suite())
     suite.addTest(test_speedups.test_suite())
     suite.addTest(test_cga.test_suite())
+    suite.addTest(test_getitem.test_suite())
+    suite.addTest(test_ndarrays.test_suite())
+    suite.addTest(test_unary_union.test_suite())
+    suite.addTest(test_pickle.test_suite())
+    suite.addTest(test_affinity.test_suite())
+    suite.addTest(test_transform.test_suite())
+    suite.addTest(test_styles.test_suite())
     return suite
 

shapely/tests/attribute-chains.txt

@@ -0,0 +1,38 @@
+Attribute Chaining
+==================
+
+See also ticket #151.
+
+    >>> from shapely.geometry import Polygon
+    >>> p = Polygon(((0.0, 0.0), (0.0, 1.0), (-1.0, 1.0), (-1.0, 0.0)))
+    >>> list(p.boundary.coords)
+    [(0.0, 0.0), (0.0, 1.0), (-1.0, 1.0), (-1.0, 0.0), (0.0, 0.0)]
+
+    >>> from shapely.geometry import Point
+    >>> print list(Point(0.0, 0.0).buffer(1.0, 1).exterior.coords)
+    [(1.0, 0.0), ..., (1.0, 0.0)]
+
+Test chained access to interiors
+
+    >>> p = Polygon(
+    ...         ((0.0, 0.0), (0.0, 1.0), (-1.0, 1.0), (-1.0, 0.0)),
+    ...         [((-0.25, 0.25), (-0.25, 0.75), (-0.75, 0.75), (-0.75, 0.25))]
+    ...     )
+    >>> p.area
+    0.75
+
+Not so much testing the exact values here, which are the responsibility of the
+geometry engine (GEOS), but that we can get chain functions and properties using
+anonymous references.
+
+    >>> print list(p.interiors[0].coords)
+    [(-0.25, 0.25), (-0.25, 0.75), (-0.75, 0.75), (-0.75, 0.25), (-0.25, 0.25)]
+    >>> xy = list(p.interiors[0].buffer(1).exterior.coords)[0]
+    >>> len(xy)
+    2
+
+Test multiple operators, boundary of a buffer
+
+    >>> print list(p.buffer(1).boundary.coords)
+    [(0.0, -1.0), (-1.0, -1.0), ...
+

shapely/tests/binascii_hex.txt

@@ -0,0 +1,47 @@
+Round-tripping geometries through hex-encoded binary
+====================================================
+
+Hex-encoded binary is the PostGIS geometry representation, and so this is a
+test of the ability to store Shapely geometries in PostGIS.
+
+Point
+-----
+
+  >>> from shapely.geometry import Point
+  >>> point = Point(0.0, 0.0)
+  >>> import binascii
+  >>> x = binascii.b2a_hex(point.wkb)
+  >>> from shapely import wkb
+  >>> shape = wkb.loads(binascii.a2b_hex(x))
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.point.Point object at ...>
+
+LineString
+----------
+
+  >>> from shapely.geometry import LineString
+  >>> line = LineString(((0.0, 0.0), (1.0, 1.0)))
+  >>> x = binascii.b2a_hex(line.wkb)
+  >>> shape = wkb.loads(binascii.a2b_hex(x))
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.linestring.LineString object at ...>
+
+Polygon
+----------
+
+  >>> from shapely.geometry import Polygon
+  >>> polygon = Polygon(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)))
+  >>> x = binascii.b2a_hex(polygon.wkb)
+  >>> shape = wkb.loads(binascii.a2b_hex(x))
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.polygon.Polygon object at ...>
+
+Polygon with hole
+-----------------
+
+  >>> polygon = Polygon(((0.0, 0.0), (0.0, 1.0), (1.0, 1.0), (1.0, 0.0)), [((0.1,0.1), (0.1,0.2), (0.2,0.2), (0.2,0.1))])
+  >>> x = binascii.b2a_hex(polygon.wkb)
+  >>> shape = wkb.loads(binascii.a2b_hex(x))
+  >>> shape # doctest: +ELLIPSIS
+  <shapely.geometry.polygon.Polygon object at ...>
+

shapely/tests/cascaded_union.txt

@@ -0,0 +1,26 @@
+Cascaded Union
+==============
+
+  >>> from shapely.ftools import partial
+  >>> import random
+  >>> 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
+
+  >>> u = cascaded_union(spots)
+  >>> u.geom_type in ('Polygon', 'MultiPolygon')
+  True
+
+

shapely/tests/dimensions.txt

@@ -0,0 +1,17 @@
+Background: see http://trac.gispython.org/lab/ticket/168
+
+  >>> from shapely.geometry import Polygon
+  >>> coords = ((0.0, 0.0, 0.0), (0.0, 1.0, 0.0), (1.0, 1.0, 0.0), (1.0, 0.0, 0.0))
+  >>> polygon = Polygon(coords)
+  >>> polygon._ndim
+  3
+  >>> gi = polygon.__geo_interface__
+  >>> gi['coordinates']
+  (((0.0, 0.0, 0.0), (0.0, 1.0, 0.0), (1.0, 1.0, 0.0), (1.0, 0.0, 0.0), (0.0, 0.0, 0.0)),)
+
+  >>> e = polygon.exterior
+  >>> e._ndim
+  3
+  >>> gi = e.__geo_interface__
+  >>> gi['coordinates']
+  ((0.0, 0.0, 0.0), (0.0, 1.0, 0.0), (1.0, 1.0, 0.0), (1.0, 0.0, 0.0), (0.0, 0.0, 0.0))

shapely/tests/invalid_intersection.txt

@@ -0,0 +1,29 @@
+Test recovery from operation on invalid geometries
+==================================================
+
+  Make a self-intersecting polygon
+
+  >>> from shapely.geometry import Polygon
+  >>> polygon_invalid = Polygon(((0, 0), (1, 1), (1, -1), (0, 1), (0, 0)))
+  >>> print polygon_invalid.is_valid # doctest: +ELLIPSIS
+  False
+
+  Intersect with a valid polygon
+
+  >>> polygon = Polygon(((-.5, -.5), (-.5, .5), (.5, .5), (.5, -5)))
+  >>> polygon.is_valid
+  True
+  >>> polygon_invalid.intersects(polygon)
+  True
+  >>> result = polygon_invalid.intersection(polygon) # doctest: +ELLIPSIS
+  Traceback (most recent call last):
+  ...
+  TopologicalError: The operation 'GEOSIntersection_r' produced a null geometry. Likely cause is invalidity of the geometry <shapely.geometry.polygon.Polygon object at ...>
+
+  Check exception symmetry
+
+  >>> result = polygon.intersection(polygon_invalid) # doctest: +ELLIPSIS
+  Traceback (most recent call last):
+  ...
+  TopologicalError: The operation 'GEOSIntersection_r' produced a null geometry. Likely cause is invalidity of the 'other' geometry <shapely.geometry.polygon.Polygon object at ...>
+

shapely/tests/linemerge.txt

@@ -0,0 +1,61 @@
+Linemerge 
+========= 
+
+  >>> from shapely.geometry import LineString, MultiLineString, Polygon 
+  >>> from shapely.ops import linemerge 
+    
+  >>> lines = MultiLineString([ 
+  ...     ((0, 0), (1, 1)), 
+  ...     ((2, 0), (2, 1), (1, 1)) 
+  ...     ]) 
+  >>> result = linemerge(lines)
+  >>> result # docstring: +ELLIPSIS
+  <shapely.geometry.linestring.LineString object at 0x...>
+  >>> result.is_ring 
+  False 
+  >>> len(result.coords) 
+  4 
+  >>> result.coords[0] 
+  (0.0, 0.0) 
+  >>> result.coords[3] 
+  (2.0, 0.0) 
+    
+  >>> lines2 = MultiLineString([ 
+  ...     ((0, 0), (1, 1)), 
+  ...     ((0, 0), (2, 0), (2, 1), (1, 1)) 
+  ...     ]) 
+  >>> result = linemerge(lines2) 
+  >>> result.is_ring 
+  True 
+  >>> len(result.coords) 
+  5 
+
+  >>> lines3 = [ 
+  ...     LineString(((0, 0), (1, 1))), 
+  ...     LineString(((0, 0), (0, 1))), 
+  ...     ] 
+  >>> result = linemerge(lines3) 
+  >>> result.is_ring 
+  False 
+  >>> len(result.coords) 
+  3 
+  >>> result.coords[0] 
+  (0.0, 1.0) 
+  >>> result.coords[2] 
+  (1.0, 1.0) 
+   
+  >>> lines4 = [ 
+  ...     ((0, 0), (1, 1)), 
+  ...     ((0, 0), (0, 1)), 
+  ...     ] 
+  >>> result.equals(linemerge(lines4)) 
+  True 
+   
+  >>> lines5 = [ 
+  ...     ((0, 0), (1, 1)), 
+  ...     ((1, 0), (0, 1)), 
+  ...     ] 
+  >>> result = linemerge(lines5) 
+  >>> result.type == 'MultiLineString' 
+  True
+

shapely/tests/polygonize.txt

@@ -0,0 +1,40 @@
+Polygonizing
+============
+
+    >>> from shapely.geometry import LineString, Point
+    >>> from shapely.ops import polygonize, polygonize_full
+    >>> lines = [
+    ...     LineString(((0, 0), (1, 1))),
+    ...     LineString(((0, 0), (0, 1))),
+    ...     LineString(((0, 1), (1, 1))),
+    ...     LineString(((1, 1), (1, 0))),
+    ...     LineString(((1, 0), (0, 0))),
+    ...     LineString(((5, 5), (6, 6))),
+    ...     Point(0, 0),
+    ...     ]
+    >>> result = polygonize(lines)
+    >>> list(result)
+    [<shapely.geometry.polygon.Polygon object at ...>, <shapely.geometry.polygon.Polygon object at ...>]
+
+    >>> lines2 = [
+    ...     ((0, 0), (1, 1)),
+    ...     ((0, 0), (0, 1)),
+    ...     ((0, 1), (1, 1)),
+    ...     ((1, 1), (1, 0)),
+    ...     ((1, 0), (0, 0)),
+    ...     ((5, 5), (6, 6)),
+    ...     ((1, 1), (100, 100)),
+    ...     ]
+    >>> result2, dangles, cuts, invalids = polygonize_full(lines2)
+    >>> len(result2)
+    2
+    >>> list(result2.geoms)
+    [<shapely.geometry.polygon.Polygon object at ...>, <shapely.geometry.polygon.Polygon object at ...>]
+    >>> list(dangles.geoms)
+    []
+    >>> list(cuts.geoms)
+    [<shapely.geometry.linestring.LineString object at ...>, <shapely.geometry.linestring.LineString object at ...>]
+    >>> print cuts.wkt
+    GEOMETRYCOLLECTION (LINESTRING (1.0000000000000000 1.0000000000000000, 100.0000000000000000 100.0000000000000000), LINESTRING (5.0000000000000000 5.0000000000000000, 6.0000000000000000 6.0000000000000000))
+    >>> list(invalids.geoms)
+    []