shapely 1.0b1__py2.4.egg → 1.0b3__py2.4.egg

shapely/geometry/multilinestring.py

@@ -0,0 +1,155 @@
+"""
+Multi-part collection of linestrings.
+"""
+
+from ctypes import byref, c_double, c_int, c_void_p, cast, POINTER, pointer
+
+from shapely.geos import lgeos
+from shapely.geometry.base import BaseGeometry, GeometrySequence
+from shapely.geometry.linestring import LineString, geos_linestring_from_py
+
+
+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 AttributeError:
+        # Fall back on list
+        L = len(ob)
+        N = len(ob[0][0])
+        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(ob[l])
+            subs[l] = cast(geom, c_void_p)
+            
+    return (lgeos.GEOSGeom_createCollection(5, subs, L), N)
+
+
+class MultiLineString(BaseGeometry):
+
+    """a multiple linestring geometry.
+    """
+
+    def __init__(self, coordinates=None):
+        """Initialize.
+
+        Parameters
+        ----------
+        
+        coordinates : sequence
+            Contains coordinate sequences or objects that provide the numpy
+            array protocol, providing an M x 2 or M x 3 (with z) array.
+
+        Example
+        -------
+
+        >>> geom = MultiLineString( [[[0.0, 0.0], [1.0, 2.0]]] )
+        >>> geom = MultiLineString( [ array([[0.0, 0.0], [1.0, 2.0]]) ] )
+        
+        Each result in a collection containing one line string.
+        """
+        BaseGeometry.__init__(self)
+
+        if coordinates is None:
+            # allow creation of null lines, to support unpickling
+            pass
+        else:
+            self._geom, self._ndim = geos_multilinestring_from_py(coordinates)
+
+    @property
+    def __geo_interface__(self):
+        return {
+            'type': 'MultiLineString',
+            'coordinates': tuple(tuple(c for c in g.coords) for g in self.geoms)
+            }
+
+    @property
+    def ctypes(self):
+        raise NotImplementedError, \
+        "Multi-part geometries have no ctypes representations"
+
+    @property
+    def __array_interface__(self):
+        """Provide the Numpy array protocol."""
+        raise NotImplementedError, \
+        "Multi-part geometries do not themselves provide the array interface"
+
+    @property
+    def coords(self):
+        raise NotImplementedError, \
+        "Multi-part geometries do not provide a coordinate sequence"
+
+    @property
+    def geoms(self):
+        return GeometrySequence(self, LineString)
+
+
+class MultiLineStringAdapter(MultiLineString):
+
+    """Adapts sequences of sequences or numpy arrays to the multilinestring
+    interface.
+    """
+    
+    context = None
+
+    def __init__(self, context):
+        self.context = context
+
+    # Override base class __del__
+    def __del__(self):
+        pass
+
+    @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])
+
+    @property
+    def _geom(self):
+        """Keeps the GEOS geometry in synch with the context."""
+        return geos_multilinestring_from_py(self.context)[0]       
+
+
+def asMultiLineString(context):
+    """Factory for MultiLineStringAdapter instances."""
+    return MultiLineStringAdapter(context)
+
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+
+if __name__ == "__main__":
+    _test()
+

shapely/geometry/multipoint.py

@@ -0,0 +1,182 @@
+"""
+Multiple points.
+"""
+
+from ctypes import byref, c_double, c_int, c_void_p, cast, POINTER, pointer
+
+from shapely.geos import lgeos
+from shapely.geometry.base import BaseGeometry, GeometrySequence
+from shapely.geometry.point import Point, geos_point_from_py
+
+
+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
+        cp = cast(array['data'][0], POINTER(c_double))
+
+        # 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)
+        n = len(ob[0])
+        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)
+
+
+class MultiPoint(BaseGeometry):
+
+    """A multiple point geometry.
+    """
+
+    def __init__(self, coordinates=None):
+        """Initialize.
+
+        Parameters
+        ----------
+        
+        coordinates : sequence or array
+            This may be an object that satisfies the numpy array protocol,
+            providing an M x 2 or M x 3 (with z) array, or it may be a sequence
+            of x, y (,z) coordinate sequences.
+
+        Example
+        -------
+
+        >>> geom = MultiPoint([[0.0, 0.0], [1.0, 2.0]])
+        >>> geom = MultiPoint(array([[0.0, 0.0], [1.0, 2.0]]))
+        
+        Each result in a line string from (0.0, 0.0) to (1.0, 2.0).
+        """
+        BaseGeometry.__init__(self)
+
+        if coordinates is None:
+            # allow creation of null lines, to support unpickling
+            pass
+        else:
+            self._geom, self._ndim = geos_multipoint_from_py(coordinates)
+
+
+    @property
+    def __geo_interface__(self):
+        return {
+            'type': 'MultiPoint',
+            'coordinates': tuple([g.coords[0] for g in self.geoms])
+            }
+
+    @property
+    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
+
+    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)
+
+    @property
+    def coords(self):
+        raise NotImplementedError, \
+        "Multipart geometries do not themselves provide coordinate sequences"
+
+    @property
+    def geoms(self):
+        return GeometrySequence(self, Point)
+        
+
+class MultiPointAdapter(MultiPoint):
+
+    """Adapts a Python coordinate pair or a numpy array to the multipoint
+    interface.
+    """
+    
+    context = None
+
+    def __init__(self, context):
+        self.context = context
+
+    # Override base class __del__
+    def __del__(self):
+        pass
+
+    @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 _geom(self):
+        """Keeps the GEOS geometry in synch with the context."""
+        return geos_multipoint_from_py(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):
+    """Factory for MultiPointAdapter instances."""
+    return MultiPointAdapter(context)
+
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+
+if __name__ == "__main__":
+    _test()
+

shapely/geometry/multipolygon.py

@@ -0,0 +1,141 @@
+"""
+Multi-part collection of polygons.
+"""
+
+from ctypes import byref, c_double, c_int, c_void_p, cast, POINTER, pointer
+
+from shapely.geos import lgeos
+from shapely.geometry.base import BaseGeometry, GeometrySequence
+from shapely.geometry.polygon import Polygon, geos_polygon_from_py
+
+
+def geos_multipolygon_from_py(ob):
+    """ob must be either a sequence or array of sequences or arrays."""
+    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)
+
+
+class MultiPolygon(BaseGeometry):
+
+    """a multiple polygon geometry.
+    """
+
+    def __init__(self, polygons=None):
+        """Initialize.
+
+        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
+        -------
+        >>> geom = 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))]
+        ...     )
+        ... ] )
+        """
+        BaseGeometry.__init__(self)
+
+        if polygons is None:
+            # allow creation of null collections, to support unpickling
+            pass
+        else:
+            self._geom, self._ndim = geos_multipolygon_from_py(polygons)
+
+    @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
+            }
+
+    @property
+    def ctypes(self):
+        raise NotImplementedError, \
+        "Multi-part geometries have no ctypes representations"
+
+    @property
+    def __array_interface__(self):
+        """Provide the Numpy array protocol."""
+        raise NotImplementedError, \
+        "Multi-part geometries do not themselves provide the array interface"
+
+    @property
+    def coords(self):
+        raise NotImplementedError, \
+        "Multi-part geometries do not provide a coordinate sequence"
+
+    @property
+    def geoms(self):
+        return GeometrySequence(self, Polygon)
+
+
+class MultiPolygonAdapter(MultiPolygon):
+
+    """Adapts sequences of sequences or numpy arrays to the multipolygon
+    interface.
+    """
+    
+    context = None
+
+    def __init__(self, context):
+        self.context = context
+
+    # Override base class __del__
+    def __del__(self):
+        pass
+
+    @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])
+
+    @property
+    def _geom(self):
+        """Keeps the GEOS geometry in synch with the context."""
+        return geos_multipolygon_from_py(self.context)[0]       
+
+
+def asMultiPolygon(context):
+    """Factory for MultiLineStringAdapter instances."""
+    return MultiPolygonAdapter(context)
+
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+
+if __name__ == "__main__":
+    _test()
+