shapely 1.0a7__py2.4.egg → 1.0b1__py2.4.egg

shapely/geometry/linestring.py

@@ -1,236 +0,0 @@
-"""
-Line strings.
-"""
-
-from ctypes import byref, c_double, c_int, cast, POINTER, pointer
-from ctypes import ArgumentError
-
-from shapely.geos import lgeos
-from shapely.geometry.base import BaseGeometry
-
-
-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]
-        n = array['shape'][1]
-        assert m >= 2
-        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:
-                dz = c_double(cp[n*i+2])
-        
-            # 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)
-        n = len(ob[0])
-        assert m >= 2
-        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:
-                dz = c_double(coords[2])
-        
-            # 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)
-
-
-class LineString(BaseGeometry):
-
-    """A line string, also known as a polyline.
-    
-    """
-
-    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
-        -------
-
-        >>> line = LineString([[0.0, 0.0], [1.0, 2.0]])
-        >>> line = LineString(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_linestring_from_py(coordinates)
-
-    @property
-    def __geo_interface__(self):
-        return {
-            'type': 'LineString',
-            'coordinates': tuple(self.coords)
-            }
-
-    @property
-    def ctypes(self):
-        if not self._ctypes_data:
-            cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
-            cs_len = c_int(0)
-            lgeos.GEOSCoordSeq_getSize(cs, byref(cs_len))
-            temp = c_double()
-            n = self._ndim
-            m = cs_len.value
-            array_type = c_double * (m * n)
-            data = array_type()
-            for i in xrange(m):
-                lgeos.GEOSCoordSeq_getX(cs, i, byref(temp))
-                data[n*i] = temp.value
-                lgeos.GEOSCoordSeq_getY(cs, i, byref(temp))
-                data[n*i+1] = temp.value
-                if n == 3: # TODO: use hasz
-                    lgeos.GEOSCoordSeq_getZ(cs, i, byref(temp))
-                    data[n*i+2] = temp.value
-            self._ctypes_data = data
-        return self._ctypes_data
-
-    @property
-    def __array_interface__(self):
-        """Provide the Numpy array protocol."""
-        return {
-            'version': 3,
-            'shape': (len(self.coords), self._ndim),
-            'typestr': '<f8',
-            'data': self.ctypes,
-            }
-
-    # Coordinate access
-
-    def set_coords(self, coordinates):
-        update_linestring_from_py(self, coordinates)
-
-    coords = property(BaseGeometry.get_coords, set_coords)
-
-
-class LineStringAdapter(LineString):
-
-    """Adapts a Python coordinate pair or a numpy array to the line string
-    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_linestring_from_py(self.context)[0]       
-
-    @property
-    def __array_interface__(self):
-        """Provide the Numpy array protocol."""
-        try:
-            return self.context.__array_interface__
-        except AttributeError:
-            return {
-                'version': 3,
-                'shape': (self._ndim,),
-                'typestr': '<f8',
-                'data': self.ctypes,
-                }
-
-    coords = property(BaseGeometry.get_coords)
-
-
-def asLineString(context):
-    """Factory for PointAdapter instances."""
-    return LineStringAdapter(context)
-
-    
-# Test runner
-def _test():
-    import doctest
-    doctest.testmod()
-
-
-if __name__ == "__main__":
-    _test()
-

shapely/geometry/multilinestring.py

@@ -1,155 +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
-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

@@ -1,190 +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
-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
-
-    @property
-    def __array_interface__(self):
-        """Provide the Numpy array protocol."""
-        return {
-            'version': 3,
-            'shape': (len(self.geoms), self._ndim),
-            'typestr': '<f8',
-            'data': self.ctypes,
-            }
-
-    @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 {
-                'version': 3,
-                'shape': (self._ndim,),
-                'typestr': '<f8',
-                'data': self.ctypes,
-                }
-
-
-def asMultiPoint(context):
-    """Factory for MultiPointAdapter instances."""
-    return MultiPointAdapter(context)
-
-
-# Test runner
-def _test():
-    import doctest
-    doctest.testmod()
-
-
-if __name__ == "__main__":
-    _test()
-