shapely 1.0__py2.4.egg

shapely/geometry/multipolygon.py

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

shapely/geometry/point.py

@@ -0,0 +1,259 @@
+"""
+Points.
+"""
+
+from ctypes import string_at, create_string_buffer, \
+    c_char_p, c_double, c_float, c_int, c_uint, c_size_t, c_ubyte, \
+    c_void_p, byref
+from ctypes import cast, POINTER
+
+from shapely.geos import lgeos, DimensionError
+from shapely.geometry.base import BaseGeometry, CoordinateSequence
+from shapely.geometry.base import exceptNull
+
+
+def geos_point_from_py(ob, update_geom=None, update_ndim=0):
+    """Create a GEOS geom from an object that is a coordinate sequence
+    or that provides the array interface.
+
+    Returns the GEOS geometry and the number of its dimensions.
+    """
+    try:
+        # From array protocol
+        array = ob.__array_interface__
+        assert len(array['shape']) == 1
+        n = array['shape'][0]
+        assert n == 2 or n == 3
+
+        cdata = array['data'][0]
+        cp = cast(cdata, POINTER(c_double))
+        dx = c_double(cp[0])
+        dy = c_double(cp[1])
+        dz = None
+        if n == 3:
+            dz = c_double(cp[2])
+            ndim = 3
+    except AttributeError:
+        # Fall back on the case of Python sequence data
+        # Accept either (x, y) or [(x, y)]
+        if type(ob[0]) == type(tuple()):
+            coords = ob[0]
+        else:
+            coords = ob
+        n = len(coords)
+        dx = c_double(coords[0])
+        dy = c_double(coords[1])
+        dz = None
+        if n == 3:
+            dz = c_double(coords[2])
+
+    if update_geom:
+        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(1, n)
+    
+    # Because of a bug in the GEOS C API, always set X before Y
+    lgeos.GEOSCoordSeq_setX(cs, 0, dx)
+    lgeos.GEOSCoordSeq_setY(cs, 0, dy)
+    if n == 3:
+        lgeos.GEOSCoordSeq_setZ(cs, 0, dz)
+   
+    if update_geom:
+        return None
+    else:
+        return lgeos.GEOSGeom_createPoint(cs), n
+
+def update_point_from_py(geom, ob):
+    geos_point_from_py(ob, geom._geom, geom._ndim)
+
+
+class Point(BaseGeometry):
+
+    """A point geometry.
+    
+    Attributes
+    ----------
+    x, y, z : float
+        Coordinate values
+
+    Example
+    -------
+    >>> p = Point(1.0, -1.0)
+    >>> str(p)
+    'POINT (1.0000000000000000 -1.0000000000000000)'
+    >>> p.y = 0.0
+    >>> p.y
+    0.0
+    >>> p.x
+    1.0
+    >>> p.array
+    [[1.0, 0.0]]
+    """
+
+    def __init__(self, *args):
+        """This *copies* the given data to a new GEOS geometry.
+        
+        Parameters
+        ----------
+        
+        There are 2 cases:
+
+        1) 1 parameter: this must satisfy the numpy array protocol.
+        2) 2 or more parameters: x, y, z : float
+            Easting, northing, and elevation.
+        """
+        BaseGeometry.__init__(self)
+        self._init_geom(*args)
+
+    def _init_geom(self, *args):
+        if len(args) == 0:
+            # allow creation of null points, to support unpickling
+            pass
+        else:
+            if len(args) == 1:
+                self._geom, self._ndim = geos_point_from_py(args[0])
+            else:
+                self._geom, self._ndim = geos_point_from_py(tuple(args))
+
+    # Coordinate getters and setters
+
+    @property
+    @exceptNull
+    def x(self):
+        """Return x coordinate."""
+        cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
+        d = c_double()
+        lgeos.GEOSCoordSeq_getX(cs, 0, byref(d))
+        return d.value
+    
+    @property
+    @exceptNull
+    def y(self):
+        """Return y coordinate."""
+        cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
+        d = c_double()
+        lgeos.GEOSCoordSeq_getY(cs, 0, byref(d))
+        return d.value
+    
+    @property
+    @exceptNull
+    def z(self):
+        """Return z coordinate."""
+        if self._ndim != 3:
+            raise DimensionError, "This point has no z coordinate."
+        cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
+        d = c_double()
+        lgeos.GEOSCoordSeq_getZ(cs, 0, byref(d))
+        return d.value
+    
+    @property
+    @exceptNull
+    def __geo_interface__(self):
+        return {
+            'type': 'Point',
+            'coordinates': self.coords[0]
+            }
+
+    @property
+    @exceptNull
+    def ctypes(self):
+        if not self._ctypes_data:
+            array_type = c_double * self._ndim
+            array = array_type()
+            array[0] = self.x
+            array[1] = self.y
+            if self._ndim == 3:
+                array[2] = self.z
+            self._ctypes_data = array
+        return self._ctypes_data
+
+    def array_interface(self):
+        """Provide the Numpy array protocol."""
+        ai = self.array_interface_base
+        ai.update({'shape': (self._ndim,)})
+        return ai
+    __array_interface__ = property(array_interface)
+
+    @property
+    @exceptNull
+    def bounds(self):
+        cs = lgeos.GEOSGeom_getCoordSeq(self._geom)
+        x = c_double()
+        y = c_double()
+        lgeos.GEOSCoordSeq_getX(cs, 0, byref(x))
+        lgeos.GEOSCoordSeq_getY(cs, 0, byref(y))
+        return (x.value, y.value, x.value, y.value)
+
+    # Coordinate access
+
+    def set_coords(self, coordinates):
+        if self._geom is None:
+            self._init_geom(coordinates)
+        else:
+            update_point_from_py(self, coordinates)
+
+    coords = property(BaseGeometry.get_coords, set_coords)
+
+
+class PointAdapter(Point):
+
+    """Adapts a Python coordinate pair or a numpy array to the point 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'][0]
+            assert n == 2 or n == 3
+            return n
+        except AttributeError:
+            # Fall back on list
+            return len(self.context)
+
+    @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_point_from_py(self.context)
+        return self.__geom
+
+    # TODO: reimplement x, y, z properties without calling invoking _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 asPoint(context):
+    """Factory for PointAdapter instances."""
+    return PointAdapter(context)
+
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+if __name__ == "__main__":
+    _test()
+