shapely 1.0__py2.4.egg → 1.0b1__py2.4.egg

shapely/geometry/multilinestring.py

@@ -1,157 +0,0 @@
-"""
-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, exceptNull
-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
-    @exceptNull
-    def geoms(self):
-        return GeometrySequence(self, LineString)
-
-
-class MultiLineStringAdapter(MultiLineString):
-
-    """Adapts sequences of sequences or numpy arrays to the multilinestring
-    interface.
-    """
-    
-    context = None
-    __geom = None
-    _owned = False
-
-    def __init__(self, context):
-        self.context = context
-
-    @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."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom = geos_multilinestring_from_py(self.context)[0]
-        return self.__geom
-
-
-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

@@ -1,187 +0,0 @@
-"""
-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, exceptNull
-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
-    @exceptNull
-    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)
-
-    @property
-    def coords(self):
-        raise NotImplementedError, \
-        "Multipart geometries do not themselves provide coordinate sequences"
-
-    @property
-    @exceptNull
-    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
-    __geom = None
-    _owned = False
-
-    def __init__(self, context):
-        self.context = context
-
-    @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."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom, n = geos_multipoint_from_py(self.context)
-        return self.__geom
-
-    @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

@@ -1,143 +0,0 @@
-"""
-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, exceptNull
-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
-    @exceptNull
-    def geoms(self):
-        return GeometrySequence(self, Polygon)
-
-
-class MultiPolygonAdapter(MultiPolygon):
-
-    """Adapts sequences of sequences or numpy arrays to the multipolygon
-    interface.
-    """
-    
-    context = None
-    __geom = None
-    _owned = False
-
-    def __init__(self, context):
-        self.context = context
-
-    @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."""
-        if self.__geom is not None:
-            lgeos.GEOSGeom_destroy(self.__geom)
-        self.__geom = geos_multipolygon_from_py(self.context)[0]
-        return self.__geom
-
-
-def asMultiPolygon(context):
-    """Factory for MultiLineStringAdapter instances."""
-    return MultiPolygonAdapter(context)
-
-
-# Test runner
-def _test():
-    import doctest
-    doctest.testmod()
-
-
-if __name__ == "__main__":
-    _test()
-