shapely 1.2.7__py2.5-win32.egg

shapely/geometry/linestring.py

@@ -0,0 +1,230 @@
+"""Line strings and related utilities
+"""
+
+from ctypes import c_double, cast, POINTER
+from ctypes import ArgumentError
+
+from shapely.geos import lgeos
+from shapely.geometry.base import BaseGeometry
+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
+        
+
+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()

shapely/geometry/multipolygon.py

@@ -0,0 +1,154 @@
+"""Collections of polygons and related utilities
+"""
+
+from ctypes import c_void_p, cast
+
+from shapely.geos import lgeos
+from shapely.geometry.base import BaseMultipartGeometry
+from shapely.geometry.polygon import Polygon, geos_polygon_from_py
+from shapely.geometry.proxy import CachingGeometryProxy
+
+__all__ = ['MultiPolygon', 'asMultiPolygon']
+
+
+class MultiPolygon(BaseMultipartGeometry):
+
+    """A collection of one or more polygons
+    
+    If component polygons overlap the collection is `invalid` and some
+    operations on it may fail.
+    
+    Attributes
+    ----------
+    geoms : sequence
+        A sequence of `Polygon` instances
+    """
+
+    def __init__(self, polygons=None, context_type='polygons'):
+        """
+        Parameters
+        ----------
+        polygons : sequence
+            A sequence of (shell, holes) tuples where shell is the sequence
+            representation of a linear ring (see linearring.py) and holes is
+            a sequence of such linear rings
+
+        Example
+        -------
+        Construct a collection from a sequence of coordinate tuples
+
+          >>> ob = MultiPolygon( [
+          ...     (
+          ...     ((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))]
+          ...     )
+          ... ] )
+          >>> len(ob.geoms)
+          1
+          >>> type(ob.geoms[0]) == Polygon
+          True
+        """
+        super(MultiPolygon, self).__init__()
+
+        if polygons is None:
+            # allow creation of null collections, to support unpickling
+            pass
+        elif context_type == 'polygons':
+            self._geom, self._ndim = geos_multipolygon_from_polygons(polygons)
+        elif context_type == 'geojson':
+            self._geom, self._ndim = geos_multipolygon_from_py(polygons)
+
+    def shape_factory(self, *args):
+        return Polygon(*args)
+
+    @property
+    def __geo_interface__(self):
+        allcoords = []
+        for geom in self.geoms:
+            coords = []
+            coords.append(tuple(geom.exterior.coords))
+            for hole in geom.interiors:
+                coords.append(tuple(hole.coords))
+            allcoords.append(coords)
+        return {
+            'type': 'MultiPolygon',
+            'coordinates': allcoords
+            }
+
+
+class MultiPolygonAdapter(CachingGeometryProxy, MultiPolygon):
+    
+    context = None
+    _owned = False
+
+    def __init__(self, context, context_type='polygons'):
+        self.context = context
+        if context_type == 'geojson':
+            self.factory = geos_multipolygon_from_py
+        elif context_type == 'polygons':
+            self.factory = geos_multipolygon_from_polygons
+
+    @property
+    def _ndim(self):
+        try:
+            # From array protocol
+            array = self.context[0][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][0])
+
+
+def asMultiPolygon(context):
+    """Adapts a sequence of objects to the MultiPolygon interface"""
+    return MultiPolygonAdapter(context)
+
+
+def geos_multipolygon_from_py(ob):
+    """ob must provide Python geo interface coordinates."""
+    L = len(ob)
+    N = len(ob[0][0][0])
+    assert L >= 1
+    assert N == 2 or N == 3
+
+    subs = (c_void_p * L)()
+    for l in xrange(L):
+        geom, ndims = geos_polygon_from_py(ob[l][0], ob[l][1:])
+        subs[l] = cast(geom, c_void_p)
+            
+    return (lgeos.GEOSGeom_createCollection(6, subs, L), N)
+
+def geos_multipolygon_from_polygons(ob):
+    """ob must be either a sequence or array of sequences or arrays."""
+    obs = getattr(ob, 'geoms', None) or ob
+    L = len(obs)
+    exemplar = obs[0]
+    try:
+        N = len(exemplar[0][0])
+    except TypeError:
+        N = exemplar._ndim
+    assert L >= 1
+    assert N == 2 or N == 3
+
+    subs = (c_void_p * L)()
+    for l in xrange(L):
+        shell = getattr(obs[l], 'exterior', None)
+        if shell is None:
+            shell = obs[l][0]
+        holes = getattr(obs[l], 'interiors', None)
+        if holes is None:
+            holes =  obs[l][1]
+        geom, ndims = geos_polygon_from_py(shell, holes)
+        subs[l] = cast(geom, c_void_p)
+            
+    return (lgeos.GEOSGeom_createCollection(6, subs, L), N)
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+if __name__ == "__main__":
+    _test()