shapely 1.2.8__py2.7-win-amd64.egg

shapely/geometry/linestring.py

@@ -0,0 +1,259 @@
+"""Line strings and related utilities
+"""
+
+from ctypes import c_double, cast, POINTER
+from ctypes import ArgumentError
+
+from shapely.geos import lgeos, TopologicalError
+from shapely.geometry.base import BaseGeometry, geom_factory
+from shapely.geometry.proxy import CachingGeometryProxy
+
+__all__ = ['LineString', 'asLineString']
+
+
+class LineString(BaseGeometry):
+    """
+    A one-dimensional figure comprising one or more line segments
+    
+    A LineString has non-zero length and zero area. It may approximate a curve
+    and need not be straight. Unlike a LinearRing, a LineString is not closed.
+    """
+
+    def __init__(self, coordinates=None):
+        """
+        Parameters
+        ----------
+        coordinates : sequence
+            A sequence of (x, y [,z]) numeric coordinate pairs or triples or
+            an object that provides the numpy array interface, including another
+            instance of LineString.
+
+        Example
+        -------
+        Create a line with two segments
+
+          >>> a = LineString([[0, 0], [1, 0], [1, 1]])
+          >>> a.length
+          2.0
+        """
+        BaseGeometry.__init__(self)
+        if coordinates is not None:
+            self._set_coords(coordinates)
+
+    @property
+    def __geo_interface__(self):
+        return {
+            'type': 'LineString',
+            'coordinates': tuple(self.coords)
+            }
+
+    @property
+    def ctypes(self):
+        if not self._ctypes_data:
+            self._ctypes_data = self.coords.ctypes
+        return self._ctypes_data
+
+    def array_interface(self):
+        """Provide the Numpy array protocol."""
+        return self.coords.array_interface()
+    
+    __array_interface__ = property(array_interface)
+
+    # Coordinate access
+    def _set_coords(self, coordinates):
+        self.empty()
+        self._geom, self._ndim = geos_linestring_from_py(coordinates)
+
+    coords = property(BaseGeometry._get_coords, _set_coords)
+
+    @property
+    def xy(self):
+        """Separate arrays of X and Y coordinate values
+        
+        Example:
+        
+          >>> x, y = LineString(((0, 0), (1, 1))).xy
+          >>> list(x)
+          [0.0, 1.0]
+          >>> list(y)
+          [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):
+
+    def __init__(self, context):
+        self.context = context
+        self.factory = geos_linestring_from_py
+
+    @property
+    def _ndim(self):
+        try:
+            # From array protocol
+            array = self.context.__array_interface__
+            n = array['shape'][1]
+            assert n == 2 or n == 3
+            return n
+        except AttributeError:
+            # Fall back on list
+            return len(self.context[0])
+
+    @property
+    def __array_interface__(self):
+        """Provide the Numpy array protocol."""
+        try:
+            return self.context.__array_interface__
+        except AttributeError:
+            return self.array_interface()
+
+    _get_coords = BaseGeometry._get_coords
+
+    def _set_coords(self, ob):
+        raise NotImplementedError(
+            "Adapters can not modify their coordinate sources")
+
+    coords = property(_get_coords)
+
+
+def asLineString(context):
+    """Adapt an object the LineString interface"""
+    return LineStringAdapter(context)
+
+
+def geos_linestring_from_py(ob, update_geom=None, update_ndim=0):
+    try:
+        # From array protocol
+        array = ob.__array_interface__
+        assert len(array['shape']) == 2
+        m = array['shape'][0]
+        if m < 2:
+            raise ValueError(
+                "LineStrings must have at least 2 coordinate tuples")
+        try:
+            n = array['shape'][1]
+        except IndexError:
+            raise ValueError(
+                "Input %s is the wrong shape for a LineString" % str(ob))
+        assert n == 2 or n == 3
+
+        # Make pointer to the coordinate array
+        try:
+            cp = cast(array['data'][0], POINTER(c_double))
+        except ArgumentError:
+            cp = array['data']
+
+        # Create a coordinate sequence
+        if update_geom is not None:
+            cs = lgeos.GEOSGeom_getCoordSeq(update_geom)
+            if n != update_ndim:
+                raise ValueError(
+                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
+                % update_ndim)
+        else:
+            cs = lgeos.GEOSCoordSeq_create(m, n)
+
+        # add to coordinate sequence
+        for i in xrange(m):
+            dx = c_double(cp[n*i])
+            dy = c_double(cp[n*i+1])
+            dz = None
+            if n == 3:
+                try:
+                    dz = c_double(cp[n*i+2])
+                except IndexError:
+                    raise ValueError("Inconsistent coordinate dimensionality")
+
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            lgeos.GEOSCoordSeq_setX(cs, i, dx)
+            lgeos.GEOSCoordSeq_setY(cs, i, dy)
+            if n == 3:
+                lgeos.GEOSCoordSeq_setZ(cs, i, dz)
+
+    except AttributeError:
+        # Fall back on list
+        m = len(ob)
+        if m < 2:
+            raise ValueError(
+                "LineStrings must have at least 2 coordinate tuples")
+        try:
+            n = len(ob[0])
+        except TypeError:
+            raise ValueError(
+                "Input %s is the wrong shape for a LineString" % str(ob))
+        assert n == 2 or n == 3
+
+        # Create a coordinate sequence
+        if update_geom is not None:
+            cs = lgeos.GEOSGeom_getCoordSeq(update_geom)
+            if n != update_ndim:
+                raise ValueError(
+                "Wrong coordinate dimensions; this geometry has dimensions: %d" \
+                % update_ndim)
+        else:
+            cs = lgeos.GEOSCoordSeq_create(m, n)
+        
+        # add to coordinate sequence
+        for i in xrange(m):
+            coords = ob[i]
+            dx = c_double(coords[0])
+            dy = c_double(coords[1])
+            dz = None
+            if n == 3:
+                try:
+                    dz = c_double(coords[2])
+                except IndexError:
+                    raise ValueError("Inconsistent coordinate dimensionality")
+        
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            lgeos.GEOSCoordSeq_setX(cs, i, dx)
+            lgeos.GEOSCoordSeq_setY(cs, i, dy)
+            if n == 3:
+                lgeos.GEOSCoordSeq_setZ(cs, i, dz)
+    
+    if update_geom is not None:
+        return None
+    else:
+        return lgeos.GEOSGeom_createLineString(cs), n
+
+def update_linestring_from_py(geom, ob):
+    geos_linestring_from_py(ob, geom._geom, geom._ndim)
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+if __name__ == "__main__":
+    _test()

shapely/geometry/multilinestring.py

@@ -0,0 +1,133 @@
+"""Collections of linestrings and related utilities
+"""
+
+from ctypes import c_double, c_void_p, cast, POINTER
+
+from shapely.geos import lgeos
+from shapely.geometry.base import BaseMultipartGeometry
+from shapely.geometry.linestring import LineString, geos_linestring_from_py
+from shapely.geometry.proxy import CachingGeometryProxy
+
+__all__ = ['MultiLineString', 'asMultiLineString']
+
+
+class MultiLineString(BaseMultipartGeometry):
+    """
+    A collection of one or more line strings
+    
+    A MultiLineString has non-zero length and zero area.
+
+    Attributes
+    ----------
+    geoms : sequence
+        A sequence of LineStrings
+    """
+
+    def __init__(self, lines=None):
+        """
+        Parameters
+        ----------
+        lines : sequence
+            A sequence of line-like coordinate sequences or objects that
+            provide the numpy array interface, including instances of
+            LineString.
+
+        Example
+        -------
+        Construct a collection containing one line string.
+
+          >>> lines = MultiLineString( [[[0.0, 0.0], [1.0, 2.0]]] )
+        """
+        super(MultiLineString, self).__init__()
+
+        if lines is None:
+            # allow creation of null lines, to support unpickling
+            pass
+        else:
+            self._geom, self._ndim = geos_multilinestring_from_py(lines)
+
+    def shape_factory(self, *args):
+        return LineString(*args)
+
+    @property
+    def __geo_interface__(self):
+        return {
+            'type': 'MultiLineString',
+            'coordinates': tuple(tuple(c for c in g.coords) for g in self.geoms)
+            }
+
+
+class MultiLineStringAdapter(CachingGeometryProxy, MultiLineString):
+    
+    context = None
+    _owned = False
+
+    def __init__(self, context):
+        self.context = context
+        self.factory = geos_multilinestring_from_py
+
+    @property
+    def _ndim(self):
+        try:
+            # From array protocol
+            array = self.context[0].__array_interface__
+            n = array['shape'][1]
+            assert n == 2 or n == 3
+            return n
+        except AttributeError:
+            # Fall back on list
+            return len(self.context[0][0])
+
+
+def asMultiLineString(context):
+    """Adapts a sequence of objects to the MultiLineString interface"""
+    return MultiLineStringAdapter(context)
+
+
+def geos_multilinestring_from_py(ob):
+    # ob must be either a sequence or array of sequences or arrays
+    try:
+        # From array protocol
+        array = ob.__array_interface__
+        assert len(array['shape']) == 1
+        L = array['shape'][0]
+        assert L >= 1
+
+        # Make pointer to the coordinate array
+        cp = cast(array['data'][0], POINTER(c_double))
+
+        # Array of pointers to sub-geometries
+        subs = (c_void_p * L)()
+
+        for l in xrange(L):
+            geom, ndims = geos_linestring_from_py(array['data'][l])
+            subs[i] = cast(geom, c_void_p)
+        N = lgeos.GEOSGeom_getDimensions(subs[0])
+    except (NotImplementedError, AttributeError):
+        obs = getattr(ob, 'geoms', ob)
+        L = len(obs)
+        exemplar = obs[0]
+        try:
+            N = len(exemplar[0])
+        except TypeError:
+            N = exemplar._ndim
+        assert L >= 1
+        assert N == 2 or N == 3
+
+        # Array of pointers to point geometries
+        subs = (c_void_p * L)()
+        
+        # add to coordinate sequence
+        for l in xrange(L):
+            geom, ndims = geos_linestring_from_py(obs[l])
+            subs[l] = cast(geom, c_void_p)
+            
+    return (lgeos.GEOSGeom_createCollection(5, subs, L), N)
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+if __name__ == "__main__":
+    _test()

shapely/geometry/multipoint.py

@@ -0,0 +1,180 @@
+"""Collections of points and related utilities
+"""
+
+from ctypes import byref, c_double, c_void_p, cast, POINTER
+from ctypes import ArgumentError
+
+from shapely.geos import lgeos
+from shapely.geometry.base import BaseMultipartGeometry, exceptNull
+from shapely.geometry.point import Point, geos_point_from_py
+from shapely.geometry.proxy import CachingGeometryProxy
+
+__all__ = ['MultiPoint', 'asMultiPoint']
+
+
+class MultiPoint(BaseMultipartGeometry):
+
+    """A collection of one or more points
+
+    A MultiPoint has zero area and zero length.
+
+    Attributes
+    ----------
+    geoms : sequence
+        A sequence of Points
+    """
+
+    def __init__(self, points=None):
+        """
+        Parameters
+        ----------
+        points : sequence
+            A sequence of (x, y [,z]) numeric coordinate pairs or triples or a
+            sequence of objects that implement the numpy array interface,
+            including instaces of Point.
+
+        Example
+        -------
+        Construct a 2 point collection
+
+          >>> ob = MultiPoint([[0.0, 0.0], [1.0, 2.0]])
+          >>> len(ob.geoms)
+          2
+          >>> type(ob.geoms[0]) == Point
+          True
+        """
+        super(MultiPoint, self).__init__()
+
+        if points is None:
+            # allow creation of empty multipoints, to support unpickling
+            pass
+        else:
+            self._geom, self._ndim = geos_multipoint_from_py(points)
+
+    def shape_factory(self, *args):
+        return Point(*args)
+
+    @property
+    def __geo_interface__(self):
+        return {
+            'type': 'MultiPoint',
+            'coordinates': tuple([g.coords[0] for g in self.geoms])
+            }
+
+    @property
+    @exceptNull
+    def ctypes(self):
+        if not self._ctypes_data:
+            temp = c_double()
+            n = self._ndim
+            m = len(self.geoms)
+            array_type = c_double * (m * n)
+            data = array_type()
+            for i in xrange(m):
+                g = self.geoms[i]._geom    
+                cs = lgeos.GEOSGeom_getCoordSeq(g)
+                lgeos.GEOSCoordSeq_getX(cs, 0, byref(temp))
+                data[n*i] = temp.value
+                lgeos.GEOSCoordSeq_getY(cs, 0, byref(temp))
+                data[n*i+1] = temp.value
+                if n == 3: # TODO: use hasz
+                    lgeos.GEOSCoordSeq_getZ(cs, 0, byref(temp))
+                    data[n*i+2] = temp.value
+            self._ctypes_data = data
+        return self._ctypes_data
+
+    @exceptNull
+    def array_interface(self):
+        """Provide the Numpy array protocol."""
+        ai = self.array_interface_base
+        ai.update({'shape': (len(self.geoms), self._ndim)})
+        return ai
+    __array_interface__ = property(array_interface)
+
+
+class MultiPointAdapter(CachingGeometryProxy, MultiPoint):
+
+    context = None
+    _owned = False
+
+    def __init__(self, context):
+        self.context = context
+        self.factory = geos_multipoint_from_py
+
+    @property
+    def _ndim(self):
+        try:
+            # From array protocol
+            array = self.context.__array_interface__
+            n = array['shape'][1]
+            assert n == 2 or n == 3
+            return n
+        except AttributeError:
+            # Fall back on list
+            return len(self.context[0])
+
+    @property
+    def __array_interface__(self):
+        """Provide the Numpy array protocol."""
+        try:
+            return self.context.__array_interface__
+        except AttributeError:
+            return self.array_interface()
+
+
+def asMultiPoint(context):
+    """Adapt a sequence of objects to the MultiPoint interface"""
+    return MultiPointAdapter(context)
+
+
+def geos_multipoint_from_py(ob):
+    try:
+        # From array protocol
+        array = ob.__array_interface__
+        assert len(array['shape']) == 2
+        m = array['shape'][0]
+        n = array['shape'][1]
+        assert m >= 1
+        assert n == 2 or n == 3
+
+        # Make pointer to the coordinate array
+        try:
+            cp = cast(array['data'][0], POINTER(c_double))
+        except ArgumentError:
+            cp = array['data']
+
+        # Array of pointers to sub-geometries
+        subs = (c_void_p * m)()
+
+        for i in xrange(m):
+            geom, ndims = geos_point_from_py(cp[n*i:n*i+2])
+            subs[i] = cast(geom, c_void_p)
+
+    except AttributeError:
+        # Fall back on list
+        m = len(ob)
+        try:
+            n = len(ob[0])
+        except TypeError:
+            n = ob[0]._ndim
+        assert n == 2 or n == 3
+
+        # Array of pointers to point geometries
+        subs = (c_void_p * m)()
+        
+        # add to coordinate sequence
+        for i in xrange(m):
+            coords = ob[i]
+            geom, ndims = geos_point_from_py(coords)
+            subs[i] = cast(geom, c_void_p)
+            
+    return lgeos.GEOSGeom_createCollection(4, subs, m), n
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+
+if __name__ == "__main__":
+    _test()