shapely 1.0__py2.4.egg

shapely/geometry/geo.py

@@ -0,0 +1,35 @@
+
+from point import PointAdapter
+from linestring import LineStringAdapter
+from polygon import PolygonAdapter
+from multipoint import MultiPointAdapter
+from multilinestring import MultiLineStringAdapter
+from multipolygon import MultiPolygonAdapter
+
+
+def asShape(context):
+    """Adapts the context to a geometry interface. The coordinates remain
+    stored in the context.
+    """
+    if hasattr(context, "__geo_interface__"):
+        ob = context.__geo_interface__
+    else:
+        ob = context
+
+    geom_type = ob.get("type").lower()
+
+    if geom_type == "point":
+        return PointAdapter(ob["coordinates"])
+    elif geom_type == "linestring":
+        return LineStringAdapter(ob["coordinates"])
+    elif geom_type == "polygon":
+        return PolygonAdapter(ob["coordinates"][0], ob["coordinates"][1:])
+    elif geom_type == "multipoint":
+        return MultiPointAdapter(ob["coordinates"])
+    elif geom_type == "multilinestring":
+        return MultiLineStringAdapter(ob["coordinates"])
+    elif geom_type == "multipolygon":
+        return MultiPolygonAdapter(ob["coordinates"])
+    else:
+        raise ValueError, "Unknown geometry type: %s" % geom_type
+

shapely/geometry/linestring.py

@@ -0,0 +1,234 @@
+"""
+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, exceptNull
+
+
+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)
+        self._init_geom(coordinates)
+
+    def _init_geom(self, coordinates):
+        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
+    @exceptNull
+    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
+
+    def array_interface(self):
+        """Provide the Numpy array protocol."""
+        ai = self.array_interface_base
+        ai.update({'shape': (len(self.coords), self._ndim)})
+        return ai
+    __array_interface__ = property(array_interface)
+
+    # Coordinate access
+
+    def set_coords(self, coordinates):
+        if self._geom is None:
+            self._init_geom(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
+    __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_linestring_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()
+
+    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

@@ -0,0 +1,157 @@
+"""
+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

@@ -0,0 +1,187 @@
+"""
+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()
+