shapely 1.2.10__py2.7-win-amd64.egg → 1.2.13__py2.7-win-amd64.egg

shapely/predicates.py

@@ -7,13 +7,13 @@ from shapely.topology import Delegating
 class BinaryPredicate(Delegating):
     def __call__(self, this, other, *args):
         self._validate(this)
-        self._validate(other)
+        self._validate(other, stop_prepared=True)
         return self.fn(this._geom, other._geom, *args)
 
 class RelateOp(Delegating):
     def __call__(self, this, other):
         self._validate(this)
-        self._validate(other)
+        self._validate(other, stop_prepared=True)
         return self.fn(this._geom, other._geom)
 
 class UnaryPredicate(Delegating):

shapely/prepared.py

@@ -27,7 +27,10 @@ class PreparedGeometry(object):
     
     def __del__(self):
         if self.__geom__ is not None:
-            lgeos.GEOSPreparedGeom_destroy(self.__geom__)
+            try:
+                lgeos.GEOSPreparedGeom_destroy(self.__geom__)
+            except AttributeError:
+                pass # lgeos might be empty on shutdown
         self.__geom__ = None
         self.context = None
     

shapely/speedups/__init__.py

@@ -0,0 +1,42 @@
+import warnings
+
+from shapely.geometry import linestring, polygon
+from shapely import coords
+
+try:
+    from shapely.speedups import _speedups
+    available = True
+    import_error_msg = None
+except ImportError:
+    import sys
+    available = False
+    import_error_msg = tuple(sys.exc_info()[1])
+
+__all__ = ['available', 'enable', 'disable']
+_orig = {}
+
+def enable():
+    if not available:
+        warnings.warn("shapely.speedups not available", RuntimeWarning)
+        return
+    
+    if _orig:
+        return
+    
+    _orig['CoordinateSequence.ctypes'] = coords.CoordinateSequence.ctypes
+    coords.CoordinateSequence.ctypes = property(_speedups.coordseq_ctypes)
+    
+    _orig['geos_linestring_from_py'] = linestring.geos_linestring_from_py
+    linestring.geos_linestring_from_py = _speedups.geos_linestring_from_py
+
+    _orig['geos_linearring_from_py']  = polygon.geos_linearring_from_py
+    polygon.geos_linearring_from_py = _speedups.geos_linearring_from_py
+
+def disable():
+    if not _orig:
+        return
+
+    coords.CoordinateSequence.ctypes = _orig['CoordinateSequence.ctypes']
+    linestring.geos_linestring_from_py = _orig['geos_linestring_from_py']
+    polygon.geos_linearring_from_py = _orig['geos_linearring_from_py']
+    _orig.clear()

shapely/speedups/_speedups.py

@@ -0,0 +1,7 @@
+def __bootstrap__():
+   global __bootstrap__, __loader__, __file__
+   import sys, pkg_resources, imp
+   __file__ = pkg_resources.resource_filename(__name__,'_speedups.pyd')
+   __loader__ = None; del __bootstrap__, __loader__
+   imp.load_dynamic(__name__,__file__)
+__bootstrap__()

shapely/tests/__init__.py

@@ -0,0 +1,28 @@
+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
+
+def test_suite():
+    suite = TestSuite()
+    suite.addTest(test_doctests.test_suite())
+    suite.addTest(test_prepared.test_suite())
+    suite.addTest(test_emptiness.test_suite())
+    suite.addTest(test_equality.test_suite())
+    suite.addTest(test_geomseq.test_suite())
+    suite.addTest(test_xy.test_suite())
+    suite.addTest(test_collection.test_suite())
+    suite.addTest(test_singularity.test_suite())
+    suite.addTest(test_validation.test_suite())
+    suite.addTest(test_mapping.test_suite())
+    suite.addTest(test_delegated.test_suite())
+    suite.addTest(test_dlls.test_suite())
+    suite.addTest(test_linear_referencing.test_suite())
+    suite.addTest(test_products_z.test_suite())
+    suite.addTest(test_box.test_suite())
+    suite.addTest(test_speedups.test_suite())
+    suite.addTest(test_cga.test_suite())
+    return suite
+

shapely/tests/test_box.py

@@ -0,0 +1,19 @@
+import unittest
+from shapely import geometry
+
+class BoxTestCase(unittest.TestCase):
+    def test_ccw(self):
+        b = geometry.box(0, 0, 1, 1, ccw=True)
+        self.assertEqual(b.exterior.coords[0], (1.0, 0.0))
+        self.assertEqual(b.exterior.coords[1], (1.0, 1.0))
+    def test_ccw_default(self):
+        b = geometry.box(0, 0, 1, 1)
+        self.assertEqual(b.exterior.coords[0], (1.0, 0.0))
+        self.assertEqual(b.exterior.coords[1], (1.0, 1.0))
+    def test_cw(self):
+        b = geometry.box(0, 0, 1, 1, ccw=False)
+        self.assertEqual(b.exterior.coords[0], (0.0, 0.0))
+        self.assertEqual(b.exterior.coords[1], (0.0, 1.0))
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(BoxTestCase)

shapely/tests/test_cga.py

@@ -0,0 +1,33 @@
+import unittest
+from shapely.geometry.polygon import LinearRing, orient, Polygon
+
+class RingOrientationTestCase(unittest.TestCase):
+    def test_ccw(self):
+        ring = LinearRing([(1,0),(0,1),(0,0)])
+        self.failUnless(ring.is_ccw)
+    def test_cw(self):
+        ring = LinearRing([(0,0),(0,1),(1,0)])
+        self.failIf(ring.is_ccw)
+
+class PolygonOrienterTestCase(unittest.TestCase):
+    def test_no_holes(self):
+        ring = LinearRing([(0,0),(0,1),(1,0)])
+        polygon = Polygon(ring)
+        self.failIf(polygon.exterior.is_ccw)
+        polygon = orient(polygon, 1)
+        self.failUnless(polygon.exterior.is_ccw)
+    def test_holes(self):
+        polygon = Polygon([(0,0),(0,1),(1,0)], 
+                        [[(0.5,0.25),(0.25,0.5),(0.25,0.25)]])
+        self.failIf(polygon.exterior.is_ccw)
+        self.failUnless(polygon.interiors[0].is_ccw)
+        polygon = orient(polygon, 1)
+        self.failUnless(polygon.exterior.is_ccw)
+        self.failIf(polygon.interiors[0].is_ccw)
+
+def test_suite():
+    loader = unittest.TestLoader()
+    return unittest.TestSuite([
+        loader.loadTestsFromTestCase(RingOrientationTestCase),
+        loader.loadTestsFromTestCase(PolygonOrienterTestCase)])
+

shapely/tests/test_collection.py

@@ -0,0 +1,11 @@
+import unittest
+from shapely.geometry.collection import GeometryCollection
+
+class CollectionTestCase(unittest.TestCase):
+    def test_array_interface(self):
+        m = GeometryCollection()
+        self.failUnlessEqual(len(m), 0)
+        self.failUnlessEqual(m.geoms, [])
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(CollectionTestCase)

shapely/tests/test_delegated.py

@@ -0,0 +1,26 @@
+import unittest
+from shapely.geometry import Point
+from shapely.impl import BaseImpl
+from shapely.geometry.base import delegated
+
+class Geometry(object):
+    impl = BaseImpl({})
+    @property
+    @delegated
+    def foo(self):
+        return self.impl['foo']()
+
+class WrapperTestCase(unittest.TestCase):
+    """When the backend has no support for a method, we get an AttributeError"""
+    def test_delegated(self):
+        self.assertRaises(AttributeError, getattr, Geometry(), 'foo')
+    def test_defaultimpl(self):
+        project_impl = Point.impl.map.pop('project', None)
+        try:
+            self.assertRaises(AttributeError, Point(0, 0).project, 1.0)
+        finally:
+            if project_impl is not None:
+                Point.impl.map['project'] = project_impl
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(WrapperTestCase)

shapely/tests/test_dlls.py

@@ -0,0 +1,16 @@
+import unittest
+
+from shapely.geos import load_dll
+
+class LoadingTestCase(unittest.TestCase):
+    def test_load(self):
+        self.assertRaises(OSError, load_dll, 'geosh_c')
+    def test_fallbacks(self):
+        a = load_dll('geosh_c', fallbacks=[
+            '/opt/local/lib/libgeos_c.dylib', # MacPorts
+            '/usr/local/lib/libgeos_c.dylib', # homebrew (Mac OS X)
+            'libgeos_c.so.1',
+            'libgeos_c.so'])
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(LoadingTestCase)

shapely/tests/test_doctests.py

@@ -0,0 +1,35 @@
+import doctest
+import unittest
+import glob
+import os
+
+optionflags = (doctest.REPORT_ONLY_FIRST_FAILURE |
+               doctest.NORMALIZE_WHITESPACE |
+               doctest.ELLIPSIS)
+
+def list_doctests():
+    print __file__
+    return [filename
+            for filename
+            in glob.glob(os.path.join(os.path.dirname(__file__), '*.txt'))]
+
+def open_file(filename, mode='r'):
+    """Helper function to open files from within the tests package."""
+    return open(os.path.join(os.path.dirname(__file__), filename), mode)
+
+def setUp(test):
+    test.globs.update(dict(
+            open_file = open_file,
+            ))
+
+def test_suite():
+    return unittest.TestSuite(
+        [doctest.DocFileSuite(os.path.basename(filename),
+                              optionflags=optionflags,
+                              setUp=setUp)
+         for filename
+         in list_doctests()])
+
+if __name__ == "__main__":
+    runner = unittest.TextTestRunner(verbosity=1)
+    runner.run(test_suite())

shapely/tests/test_emptiness.py

@@ -0,0 +1,19 @@
+import unittest
+from shapely.geometry.base import BaseGeometry
+from shapely.geometry import Point
+
+class EmptinessTestCase(unittest.TestCase):
+    def test_empty_base(self):
+        g = BaseGeometry()
+        self.failUnless(g._is_empty, True)
+    def test_empty_point(self):
+        p = Point()
+        self.failUnless(p._is_empty, True)
+    def test_emptying_point(self):
+        p = Point(0, 0)
+        self.failIf(p._is_empty, False)
+        p.empty()
+        self.failUnless(p._is_empty, True)
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(EmptinessTestCase)

shapely/tests/test_equality.py

@@ -0,0 +1,30 @@
+import unittest
+from shapely import geometry
+
+
+class PointEqualityTestCase(unittest.TestCase):
+    
+    def test_equals_exact(self):
+        p1 = geometry.Point(1.0, 1.0)
+        p2 = geometry.Point(2.0, 2.0)
+        self.failIf(p1.equals(p2))
+        self.failIf(p1.equals_exact(p2, 0.001))
+
+    def test_almost_equals_default(self):
+        p1 = geometry.Point(1.0, 1.0)
+        p2 = geometry.Point(1.0+1e-7, 1.0+1e-7) # almost equal to 6 places
+        p3 = geometry.Point(1.0+1e-6, 1.0+1e-6) # not almost equal
+        self.failUnless(p1.almost_equals(p2))
+        self.failIf(p1.almost_equals(p3))
+
+    def test_almost_equals(self):
+        p1 = geometry.Point(1.0, 1.0)
+        p2 = geometry.Point(1.1, 1.1)
+        self.failIf(p1.equals(p2))
+        self.failUnless(p1.almost_equals(p2, 0))
+        self.failIf(p1.almost_equals(p2, 1))
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(
+                                    PointEqualityTestCase
+                                    )

shapely/tests/test_geomseq.py

@@ -0,0 +1,11 @@
+import unittest
+from shapely import geometry
+
+class MultiLineTestCase(unittest.TestCase):
+    def test_array_interface(self):
+        m = geometry.MultiLineString([((0, 0), (1, 1)), ((2, 2), (3, 3))])
+        ai = m.geoms[0].__array_interface__
+        self.failUnlessEqual(ai['shape'], (2, 2))
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(MultiLineTestCase)

shapely/tests/test_linear_referencing.py

@@ -0,0 +1,67 @@
+import unittest
+from shapely.geometry import Point, LineString, MultiLineString
+
+class LinearReferencingTestCase(unittest.TestCase):
+    def setUp(self):
+        self.point = Point(1, 1)
+        self.line1 = LineString(([0, 0], [2, 0]))
+        self.line2 = LineString(([3, 0], [3, 6]))
+        self.multiline = MultiLineString([
+            list(self.line1.coords), list(self.line2.coords)
+        ]) 
+
+    def test_line1_project(self):
+        self.assertEqual(self.line1.project(self.point), 1.0)
+        self.assertEqual(self.line1.project(self.point, normalized=True), 0.5)
+
+    def test_line2_project(self):
+        self.assertEqual(self.line2.project(self.point), 1.0)
+        self.assertAlmostEqual(self.line2.project(self.point, normalized=True),
+            0.16666666666, 8)
+
+    def test_multiline_project(self):
+        self.assertEqual(self.multiline.project(self.point), 1.0)
+        self.assertEqual(self.multiline.project(self.point, normalized=True),
+            0.125)
+
+    def test_not_supported_project(self):
+        self.assertRaises(TypeError, self.point.buffer(1.0).project,
+            self.point)
+
+    def test_not_on_line_project(self):
+        # Points that aren't on the line project to 0.
+        self.assertEqual(self.line1.project(Point(-10,-10)), 0.0)
+
+    def test_line1_interpolate(self):
+        self.failUnless(self.line1.interpolate(0.5).equals(Point(0.5, 0.0)))
+        self.failUnless(
+            self.line1.interpolate(0.5, normalized=True).equals(
+                Point(1.0, 0.0)))
+
+    def test_line2_interpolate(self):
+        self.failUnless(self.line2.interpolate(0.5).equals(Point(3.0, 0.5)))
+        self.failUnless(
+            self.line2.interpolate(0.5, normalized=True).equals(
+                Point(3.0, 3.0)))
+
+    def test_multiline_interpolate(self):
+        self.failUnless(self.multiline.interpolate(0.5).equals(
+            Point(0.5, 0.0)))
+        self.failUnless(
+            self.multiline.interpolate(0.5, normalized=True).equals(
+                Point(3.0, 2.0)))
+
+    def test_line_ends_interpolate(self):
+        # Distances greater than length of the line or less than
+        # zero yield the line's ends.
+        self.failUnless(self.line1.interpolate(-1000).equals(Point(0.0, 0.0)))
+        self.failUnless(self.line1.interpolate(1000).equals(Point(2.0, 0.0)))
+
+def test_suite():
+    try:
+        LineString(([0, 0], [2, 0])).project(Point(0, 0))
+    except AttributeError:
+        return lambda x: None
+    return unittest.TestLoader().loadTestsFromTestCase(
+                                  LinearReferencingTestCase
+                                  )

shapely/tests/test_mapping.py

@@ -0,0 +1,11 @@
+import unittest
+from shapely.geometry import Point, mapping
+
+class MappingTestCase(unittest.TestCase):
+    def test_point(self):
+        m = mapping(Point(0, 0))
+        self.failUnlessEqual(m['type'], 'Point')
+        self.failUnlessEqual(m['coordinates'], (0.0, 0.0))
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(MappingTestCase)

shapely/tests/test_prepared.py

@@ -0,0 +1,28 @@
+import unittest
+from shapely import prepared
+from shapely import geometry
+
+
+class PreparedGeometryTestCase(unittest.TestCase):
+    
+    def test_prepared(self):
+        polygon = geometry.Polygon([
+            (0, 0), (1, 0), (1, 1), (0, 1)
+        ])
+        p = prepared.PreparedGeometry(polygon)
+        self.assertTrue(p.contains(geometry.Point(0.5, 0.5)))
+        self.assertFalse(p.contains(geometry.Point(0.5, 1.5)))
+
+    def test_op_not_allowed(self):
+        p = prepared.PreparedGeometry(geometry.Point(0.0, 0.0).buffer(1.0))
+        self.assertRaises(ValueError, geometry.Point(0.0, 0.0).union, p)
+
+    def test_predicate_not_allowed(self):
+        p = prepared.PreparedGeometry(geometry.Point(0.0, 0.0).buffer(1.0))
+        self.assertRaises(ValueError, geometry.Point(0.0, 0.0).contains, p)
+
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(
+                                    PreparedGeometryTestCase
+                                    )

shapely/tests/test_products_z.py

@@ -0,0 +1,14 @@
+import unittest
+from shapely.geometry import LineString
+
+class ProductZTestCase(unittest.TestCase):
+    def test_line_intersection(self):
+        line1 = LineString([(0,0,0), (1,1,1)])
+        line2 = LineString([(0,1,1), (1,0,0)])
+        interxn = line1.intersection(line2)
+        self.failUnless(interxn.has_z)
+        self.failUnless(interxn._ndim == 3)
+        self.failUnless(0.0 <= interxn.z <= 1.0)
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(ProductZTestCase)

shapely/tests/test_singularity.py

@@ -0,0 +1,15 @@
+import unittest
+from shapely.geometry import Polygon
+
+class PolygonTestCase(unittest.TestCase):
+    def test_polygon_3(self):
+        p = (1.0, 1.0)
+        poly = Polygon([p, p, p])
+        self.failUnlessEqual(poly.bounds, (1.0, 1.0, 1.0, 1.0))
+    def test_polygon_5(self):
+        p = (1.0, 1.0)
+        poly = Polygon([p, p, p, p, p])
+        self.failUnlessEqual(poly.bounds, (1.0, 1.0, 1.0, 1.0))
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(PolygonTestCase)

shapely/tests/test_speedups.py

@@ -0,0 +1,38 @@
+import unittest
+
+from shapely import speedups
+from shapely.geometry import LineString, Polygon
+
+class SpeedupsTestCase(unittest.TestCase):
+    
+    def setUp(self):
+        self.assertFalse(speedups._orig)
+        speedups.enable()
+        self.assertTrue(speedups._orig)
+        
+    def tearDown(self):
+        self.assertTrue(speedups._orig)
+        speedups.disable()
+        self.assertFalse(speedups._orig)
+
+    def test_create_linestring(self):
+        ls = LineString([(0, 0), (1, 0), (1, 2)])
+        self.assertEqual(ls.length, 3)
+
+    def test_create_polygon(self):
+        p = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)])
+        self.assertEqual(p.length, 8)
+
+    def test_create_polygon_from_linestring(self):
+        ls = LineString([(0, 0), (2, 0), (2, 2), (0, 2)])
+        p = Polygon(ls)
+        self.assertEqual(p.length, 8)
+
+
+def test_suite():
+    if speedups.available:
+        return unittest.TestLoader().loadTestsFromTestCase(
+            SpeedupsTestCase
+        )
+    else:
+        return lambda x: None

shapely/tests/test_validation.py

@@ -0,0 +1,10 @@
+import unittest
+from shapely.geometry import *
+from shapely.validation import explain_validity
+
+class ValidationTestCase(unittest.TestCase):
+    def test_valid(self):
+        self.failUnlessEqual(explain_validity(Point(0, 0)), 'Valid Geometry')
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(ValidationTestCase)

shapely/tests/test_xy.py

@@ -0,0 +1,14 @@
+import unittest
+from shapely import geometry
+
+class XYTestCase(unittest.TestCase):
+    """New geometry/coordseq method 'xy' makes numpy interop easier"""
+    def test_arrays(self):
+        x, y = geometry.LineString(((0, 0), (1, 1))).xy
+        self.failUnless(len(x) == 2)
+        self.failUnless(list(x) == [0.0, 1.0])
+        self.failUnless(len(y) == 2)
+        self.failUnless(list(y) == [0.0, 1.0])
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromTestCase(XYTestCase)

shapely/tests/threading_test.py

@@ -0,0 +1,37 @@
+import threading
+
+def main():
+    num_threads = 10
+    use_threads = True
+    
+    if not use_threads:
+        # Run core code
+        runShapelyBuilding()
+    else:
+        threads = [threading.Thread(target=runShapelyBuilding, name=str(i), args=(i,)) for i in range(num_threads)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+        
+def runShapelyBuilding(num):
+    print "%s: Running shapely tests on wkb" % num
+    import shapely.geos
+    print "%s GEOS Handle: %s" % (num, shapely.geos.lgeos.geos_handle)
+    import shapely.wkt
+    import shapely.wkb
+    p = shapely.wkt.loads("POINT (0 0)")
+    print "%s WKT: %s" % (num, shapely.wkt.dumps(p))
+    wkb = shapely.wkb.dumps(p)
+    print "%s WKB: %s" % (num, wkb.encode('hex'))
+    
+    for i in xrange(10):
+        obj = shapely.wkb.loads(wkb)
+    
+    print "%s GEOS Handle: %s" % (num, shapely.geos.lgeos.geos_handle)
+    print "Done %s" % num
+    
+# Run main
+if __name__ == '__main__':
+   main()   
+