shapely 1.2.7__py2.5-win32.egg → 1.2.8__py2.5-win32.egg

EGG-INFO/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: Shapely
-Version: 1.2.7
+Version: 1.2.8
 Summary: Geometric objects, predicates, and operations
 Home-page: http://trac.gispython.org/lab/wiki/Shapely
 Author: Sean Gillies

shapely/ctypes_declarations.py

@@ -259,6 +259,9 @@ def prototype(lgeos, geosVersion):
         # Linear referencing features aren't found in versions 1.5,
         # but not in all libs versioned 1.6.0 either!
         if hasattr(lgeos, 'GEOSProject'):
+            lgeos.GEOSSingleSidedBuffer.restype = ctypes.c_void_p
+            lgeos.GEOSSingleSidedBuffer.argtypes = [ctypes.c_void_p, ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_double, ctypes.c_int]
+
             lgeos.GEOSProject.restype = ctypes.c_double
             lgeos.GEOSProject.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
 

shapely/ftools.py

@@ -0,0 +1,78 @@
+# Backport some of functools from Python 2.5 standard library for Shapely 
+# on Python 2.4
+#
+# Python module wrapper for _functools C module
+# to allow utilities written in Python to be added
+# to the functools module.
+# Written by Nick Coghlan <ncoghlan at gmail.com>
+# Copyright (C) 2006 Python Software Foundation.
+# See C source code for _functools credits/copyright
+#
+# _functools module written and maintained
+# by Hye-Shik Chang <perky@FreeBSD.org>
+# with adaptations by Raymond Hettinger <python@rcn.com>
+# Copyright (c) 2004, 2005, 2006 Python Software Foundation.
+# All rights reserved.
+
+def _partial(func, *args, **keywords):
+    def newfunc(*fargs, **fkeywords):
+        newkeywords = keywords.copy()
+        newkeywords.update(fkeywords)
+        return func(
+            *(args + fargs), **newkeywords)
+    newfunc.func = func
+    newfunc.args = args
+    newfunc.keywords = keywords
+    return newfunc
+
+# update_wrapper() and wraps() are tools to help write
+# wrapper functions that can handle naive introspection
+
+WRAPPER_ASSIGNMENTS = ('__module__', '__name__', '__doc__')
+WRAPPER_UPDATES = ('__dict__',)
+def _update_wrapper(wrapper,
+                   wrapped,
+                   assigned = WRAPPER_ASSIGNMENTS,
+                   updated = WRAPPER_UPDATES):
+    """Update a wrapper function to look like the wrapped function
+
+       wrapper is the function to be updated
+       wrapped is the original function
+       assigned is a tuple naming the attributes assigned directly
+       from the wrapped function to the wrapper function (defaults to
+       functools.WRAPPER_ASSIGNMENTS)
+       updated is a tuple naming the attributes of the wrapper that
+       are updated with the corresponding attribute from the wrapped
+       function (defaults to functools.WRAPPER_UPDATES)
+    """
+    for attr in assigned:
+        setattr(wrapper, attr, getattr(wrapped, attr))
+    for attr in updated:
+        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+    # Return the wrapper so this can be used as a decorator via partial()
+    return wrapper
+
+def _wraps(wrapped,
+          assigned = WRAPPER_ASSIGNMENTS,
+          updated = WRAPPER_UPDATES):
+    """Decorator factory to apply update_wrapper() to a wrapper function
+
+       Returns a decorator that invokes update_wrapper() with the decorated
+       function as the wrapper argument and the arguments to wraps() as the
+       remaining arguments. Default arguments are as for update_wrapper().
+       This is a convenience function to simplify applying partial() to
+       update_wrapper().
+    """
+    return _partial(_update_wrapper, wrapped=wrapped,
+                   assigned=assigned, updated=updated)
+
+# Use stdlib's functools if available
+try:
+    from functools import partial, update_wrapper, wraps
+    have_functools = 1
+except ImportError:
+    partial = _partial
+    update_wrapper = _update_wrapper
+    wraps = _wraps
+    have_functools = 0
+

shapely/geometry/base.py

@@ -1,11 +1,11 @@
 """Base geometry class and utilities
 """
 
-from functools import wraps
 import sys
 import warnings
 
 from shapely.coords import CoordinateSequence
+from shapely.ftools import wraps
 from shapely.geos import lgeos
 from shapely.impl import DefaultImplementation, delegated
 from shapely import wkb, wkt

shapely/geometry/linestring.py

@@ -4,8 +4,8 @@
 from ctypes import c_double, cast, POINTER
 from ctypes import ArgumentError
 
-from shapely.geos import lgeos
-from shapely.geometry.base import BaseGeometry
+from shapely.geos import lgeos, TopologicalError
+from shapely.geometry.base import BaseGeometry, geom_factory
 from shapely.geometry.proxy import CachingGeometryProxy
 
 __all__ = ['LineString', 'asLineString']
@@ -79,6 +79,35 @@ class LineString(BaseGeometry):
           [0.0, 1.0]
         """
         return self.coords.xy
+    
+    def parallel_offset(
+        self, distance, side, 
+        resolution=16, join_style=1, mitre_limit=1.0):
+        
+        """Returns a LineString or MultiLineString geometry at a distance from
+        the object on its right or its left side.
+        
+        Distance must be a positive float value. The side parameter may be
+        'left' or 'right'. The resolution of the buffer around each vertex of
+        the object increases by increasing the resolution keyword parameter or
+        third positional parameter.
+        
+        The join style is for outside corners between line segments. Accepted
+        values are 1 => ROUND, 2 => MITRE, 3 => BEVEL.
+        
+        The mitre ratio limit is used for very sharp corners. It is the ratio
+        of the distance from the corner to the end of the mitred offset corner.
+        When two line segments meet at a sharp angle, a miter join will extend
+        far beyond the original geometry. To prevent unreasonable geometry, the
+        mitre limit allows controlling the maximum length of the join corner.
+        Corners with a ratio which exceed the limit will be beveled."""
+
+        try:
+            return geom_factory(self.impl['parallel_offset'](
+                self, distance, resolution, join_style, mitre_limit, 
+                bool(side=='left')))
+        except WindowsError:
+            raise TopologicalError()
         
 
 class LineStringAdapter(CachingGeometryProxy, LineString):

shapely/geos.py

@@ -3,7 +3,6 @@ Proxies for the libgeos_c shared lib, GEOS-specific exceptions, and utilities
 """
 
 import atexit
-import functools
 import logging
 import os
 import sys
@@ -13,8 +12,11 @@ import ctypes
 from ctypes import cdll, CDLL, PyDLL, CFUNCTYPE, c_char_p, c_void_p, string_at
 from ctypes.util import find_library
 
+import ftools
 from ctypes_declarations import prototype
 
+
+
 # Begin by creating a do-nothing handler and adding to this module's logger.
 class NullHandler(logging.Handler):
     def emit(self, record):
@@ -267,7 +269,7 @@ class LGEOS15(LGEOSBase):
         for key in filter(lambda x: not x.endswith('_r'), keys):
             if key + '_r' in keys:
                 reentr_func = getattr(self._lgeos, key + '_r')
-                attr = functools.partial(reentr_func, self.geos_handle)
+                attr = ftools.partial(reentr_func, self.geos_handle)
                 attr.__name__ = reentr_func.__name__
                 setattr(self, key, attr)
             else:
@@ -349,6 +351,7 @@ class LGEOS16LR(LGEOS16):
     def __init__(self, dll):
         super(LGEOS16LR, self).__init__(dll)
 
+        self.methods['parallel_offset'] = self.GEOSSingleSidedBuffer
         self.methods['project'] = self.GEOSProject
         self.methods['project_normalized'] = self.GEOSProjectNormalized
         self.methods['interpolate'] = self.GEOSInterpolate

shapely/impl.py

@@ -11,7 +11,7 @@ This is layer number 2 from the list below.
 Shapely 1.2 includes a GEOS backend and it is the default.
 """
 
-from functools import wraps
+from ftools import wraps
 
 from shapely.coords import BoundsOp
 from shapely.geos import lgeos
@@ -98,7 +98,8 @@ IMPL16 = {
     }
 
 IMPL16LR = {
-    'project_normalized': (ProjectOp, 'project_normalized'),
+	'parallel_offset': (UnaryTopologicalOp, 'parallel_offset'),
+	'project_normalized': (ProjectOp, 'project_normalized'),
     'project': (ProjectOp, 'project'),
     'interpolate_normalized': (InterpolateOp, 'interpolate_normalized'),
     'interpolate': (InterpolateOp, 'interpolate'),