shapely 1.2.7__py2.7-win32.egg

shapely/geometry/point.py

@@ -0,0 +1,241 @@
+"""Points and related utilities
+"""
+
+from ctypes import c_double
+from ctypes import cast, POINTER
+
+from shapely.geos import lgeos, DimensionError
+from shapely.geometry.base import BaseGeometry
+from shapely.geometry.proxy import CachingGeometryProxy
+
+__all__ = ['Point', 'asPoint']
+
+
+class Point(BaseGeometry):
+    """
+    A zero dimensional feature
+
+    A point has zero length and zero area. 
+    
+    Attributes
+    ----------
+    x, y, z : float
+        Coordinate values
+
+    Example
+    -------
+    
+      >>> p = Point(1.0, -1.0)
+      >>> print p
+      POINT (1.0000000000000000 -1.0000000000000000)
+      >>> p.y
+      -1.0
+      >>> p.x
+      1.0
+    """
+
+    def __init__(self, *args):
+        """
+        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)
+        if len(args) > 0:
+            self._set_coords(*args)
+
+    # Coordinate getters and setters
+
+    @property
+    def x(self):
+        """Return x coordinate."""
+        return self.coords[0][0]
+    
+    @property
+    def y(self):
+        """Return y coordinate."""
+        return self.coords[0][1]
+    
+    @property
+    def z(self):
+        """Return z coordinate."""
+        if self._ndim != 3:
+            raise DimensionError("This point has no z coordinate.")
+        return self.coords[0][2]
+    
+    @property
+    def __geo_interface__(self):
+        return {
+            'type': 'Point',
+            'coordinates': self.coords[0]
+            }
+
+    @property
+    def ctypes(self):
+        if not self._ctypes_data:
+            array_type = c_double * self._ndim
+            array = array_type()
+            xy = self.coords[0]
+            array[0] = xy[0]
+            array[1] = xy[1]
+            if self._ndim == 3:
+                array[2] = xy[2]
+            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
+    def bounds(self):
+        xy = self.coords[0]
+        return (xy[0], xy[1], xy[0], xy[1])
+
+    # Coordinate access
+
+    def _set_coords(self, *args):
+        self.empty()
+        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))
+
+    coords = property(BaseGeometry._get_coords, _set_coords)
+
+    @property
+    def xy(self):
+        """Separate arrays of X and Y coordinate values
+        
+        Example:
+        
+          >>> x, y = Point(0, 0).xy
+          >>> list(x)
+          [0.0]
+          >>> list(y)
+          [0.0]
+        """
+        return self.coords.xy
+
+
+class PointAdapter(CachingGeometryProxy, Point):
+
+    _owned = False
+
+    def __init__(self, context):
+        self.context = context
+        self.factory = geos_point_from_py
+
+    @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 __array_interface__(self):
+        """Provide the Numpy array protocol."""
+        try:
+            return self.context.__array_interface__
+        except AttributeError:
+            return self.array_interface()
+
+    _get_coords = BaseGeometry._get_coords
+
+    def _set_coords(self, ob):
+        raise NotImplementedError("Adapters can not modify their sources")
+
+    coords = property(_get_coords)
+
+
+def asPoint(context):
+    """Adapt an object to the Point interface"""
+    return PointAdapter(context)
+
+
+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
+
+        dz = None
+        da = array['data']
+        if type(da) == type((0,)):
+            cdata = da[0]
+            cp = cast(cdata, POINTER(c_double))
+            dx = c_double(cp[0])
+            dy = c_double(cp[1])
+            if n == 3:
+                dz = c_double(cp[2])
+                ndim = 3
+        else:
+            dx, dy = da[0:2]
+            if n == 3:
+                dz = da[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)
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+if __name__ == "__main__":
+    _test()

shapely/geometry/polygon.py

@@ -0,0 +1,449 @@
+"""Polygons and their linear ring components
+"""
+
+from ctypes import c_double, c_void_p, cast, POINTER
+from ctypes import ArgumentError
+import weakref
+from shapely.geos import lgeos
+from shapely.geometry.base import BaseGeometry
+from shapely.geometry.linestring import LineString, LineStringAdapter
+from shapely.geometry.proxy import PolygonProxy
+
+__all__ = ['Polygon', 'asPolygon', 'LinearRing', 'asLinearRing']
+
+
+class LinearRing(LineString):
+    """
+    A closed one-dimensional feature comprising one or more line segments
+
+    A LinearRing that crosses itself or touches itself at a single point is
+    invalid and operations on it may fail.
+    """
+    
+    def __init__(self, coordinates=None):
+        """
+        Parameters
+        ----------
+        coordinates : sequence
+            A sequence of (x, y [,z]) numeric coordinate pairs or triples
+
+        Rings are implicitly closed. There is no need to specific a final
+        coordinate pair identical to the first.
+
+        Example
+        -------
+        Construct a square ring.
+
+          >>> ring = LinearRing( ((0, 0), (0, 1), (1 ,1 ), (1 , 0)) )
+          >>> ring.is_closed
+          True
+          >>> ring.length
+          4.0
+        """
+        BaseGeometry.__init__(self)
+        if coordinates is not None:
+            self._set_coords(coordinates)
+
+    @property
+    def __geo_interface__(self):
+        return {
+            'type': 'LinearRing',
+            'coordinates': tuple(self.coords)
+            }
+
+    # Coordinate access
+
+    _get_coords = BaseGeometry._get_coords
+
+    def _set_coords(self, coordinates):
+        self.empty()
+        self._geom, self._ndim = geos_linearring_from_py(coordinates)
+
+    coords = property(_get_coords, _set_coords)
+
+
+class LinearRingAdapter(LineStringAdapter):
+
+    __p__ = None
+
+    def __init__(self, context):
+        self.context = context
+        self.factory = geos_linearring_from_py
+
+    @property
+    def __geo_interface__(self):
+        return {
+            'type': 'LinearRing',
+            'coordinates': tuple(self.coords)
+            }
+
+    coords = property(BaseGeometry._get_coords)
+
+
+def asLinearRing(context):
+    """Adapt an object to the LinearRing interface"""
+    return LinearRingAdapter(context)
+
+
+class InteriorRingSequence(object):
+
+    _factory = None
+    _geom = None
+    __p__ = None
+    _ndim = None
+    _index = 0
+    _length = 0
+    __rings__ = None
+    _gtag = None
+
+    def __init__(self, parent):
+        self.__p__ = parent
+        self._geom = parent._geom
+        self._ndim = parent._ndim
+
+    def __iter__(self):
+        self._index = 0
+        self._length = self.__len__()
+        return self
+
+    def next(self):
+        if self._index < self._length:
+            ring = self._get_ring(self._index)
+            self._index += 1
+            return ring
+        else:
+            raise StopIteration 
+
+    def __len__(self):
+        return lgeos.GEOSGetNumInteriorRings(self._geom)
+
+    def __getitem__(self, i):
+        M = self.__len__()
+        if i + M < 0 or i >= M:
+            raise IndexError("index out of range")
+        if i < 0:
+            ii = M + i
+        else:
+            ii = i
+        return self._get_ring(i)
+
+    @property
+    def _longest(self):
+        max = 0
+        for g in iter(self):
+            l = len(g.coords)
+            if l > max:
+                max = l
+
+    def gtag(self):
+        return hash(repr(self.__p__))
+
+    def _get_ring(self, i):
+        gtag = self.gtag()
+        if gtag != self._gtag:
+            self.__rings__ = {}
+        if i not in self.__rings__:
+            g = lgeos.GEOSGetInteriorRingN(self._geom, i)
+            ring = LinearRing()
+            ring.__geom__ = g
+            ring.__p__ = self
+            ring._owned = True
+            ring._ndim = self._ndim
+            self.__rings__[i] = weakref.ref(ring)
+        return self.__rings__[i]()
+        
+
+class Polygon(BaseGeometry):
+    """
+    A two-dimensional figure bounded by a linear ring
+
+    A polygon has a non-zero area. It may have one or more negative-space
+    "holes" which are also bounded by linear rings. If any rings cross each
+    other, the feature is invalid and operations on it may fail.
+
+    Attributes
+    ----------
+    exterior : LinearRing
+        The ring which bounds the positive space of the polygon.
+    interiors : sequence
+        A sequence of rings which bound all existing holes.
+    """
+
+    _exterior = None
+    _interiors = []
+    _ndim = 2
+
+    def __init__(self, shell=None, holes=None):
+        """
+        Parameters
+        ----------
+        shell : sequence
+            A sequence of (x, y [,z]) numeric coordinate pairs or triples
+        holes : sequence
+            A sequence of objects which satisfy the same requirements as the
+            shell parameters above
+
+        Example
+        -------
+        Create a square polygon with no holes
+
+          >>> coords = ((0., 0.), (0., 1.), (1., 1.), (1., 0.), (0., 0.))
+          >>> polygon = Polygon(coords)
+          >>> polygon.area
+          1.0
+        """
+        BaseGeometry.__init__(self)
+
+        if shell is not None:
+            self._geom, self._ndim = geos_polygon_from_py(shell, holes)
+
+    @property
+    def exterior(self):
+        if self.is_empty:
+            return None
+        elif self._exterior is None or self._exterior() is None:
+            g = lgeos.GEOSGetExteriorRing(self._geom)
+            ring = LinearRing()
+            ring.__geom__ = g
+            ring.__p__ = self
+            ring._owned = True
+            ring._ndim = self._ndim
+            self._exterior = weakref.ref(ring)
+        return self._exterior()
+
+    @property
+    def interiors(self):
+        if self.is_empty:
+            return []
+        return InteriorRingSequence(self)
+
+    @property
+    def ctypes(self):
+        if not self._ctypes_data:
+            self._ctypes_data = self.exterior.ctypes
+        return self._ctypes_data
+
+    @property
+    def __array_interface__(self):
+        raise NotImplementedError(
+        "A polygon does not itself provide the array interface. Its rings do.")
+
+    def _get_coords(self):
+        raise NotImplementedError(
+        "Component rings have coordinate sequences, but the polygon does not")
+
+    def _set_coords(self, ob):
+        raise NotImplementedError(
+        "Component rings have coordinate sequences, but the polygon does not")
+
+    @property
+    def coords(self):
+        raise NotImplementedError(
+        "Component rings have coordinate sequences, but the polygon does not")
+
+    @property
+    def __geo_interface__(self):
+        coords = [tuple(self.exterior.coords)]
+        for hole in self.interiors:
+            coords.append(tuple(hole.coords))
+        return {
+            'type': 'Polygon',
+            'coordinates': tuple(coords)
+            }
+
+
+class PolygonAdapter(PolygonProxy, Polygon):
+    
+    def __init__(self, shell, holes=None):
+        self.shell = shell
+        self.holes = holes
+        self.context = (shell, holes)
+        self.factory = geos_polygon_from_py
+
+    @property
+    def _ndim(self):
+        try:
+            # From array protocol
+            array = self.shell.__array_interface__
+            n = array['shape'][1]
+            assert n == 2 or n == 3
+            return n
+        except AttributeError:
+            # Fall back on list
+            return len(self.shell[0])
+
+
+def asPolygon(shell, holes=None):
+    """Adapt objects to the Polygon interface"""
+    return PolygonAdapter(shell, holes)
+
+
+def geos_linearring_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]
+        if m < 3:
+            raise ValueError(
+                "A LinearRing must have at least 3 coordinate tuples")
+        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']
+
+        # Add closing coordinates to sequence?
+        if cp[0] != cp[m*n-n] or cp[1] != cp[m*n-n+1]:
+            M = m + 1
+        else:
+            M = m
+
+        # 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)
+
+        # Add closing coordinates to sequence?
+        if M > m:
+            dx = c_double(cp[0])
+            dy = c_double(cp[1])
+            dz = None
+            if n == 3:
+                dz = c_double(cp[2])
+        
+            # Because of a bug in the GEOS C API, 
+            # always set X before Y
+            lgeos.GEOSCoordSeq_setX(cs, M-1, dx)
+            lgeos.GEOSCoordSeq_setY(cs, M-1, dy)
+            if n == 3:
+                lgeos.GEOSCoordSeq_setZ(cs, M-1, dz)
+            
+    except AttributeError:
+        # Fall back on list
+        m = len(ob)
+        n = len(ob[0])
+        if m < 3:
+            raise ValueError(
+                "A LinearRing must have at least 3 coordinate tuples")
+        assert (n == 2 or n == 3)
+
+        # Add closing coordinates if not provided
+        if m == 3 or ob[0][0] != ob[-1][0] or ob[0][1] != ob[-1][1]:
+            M = m + 1
+        else:
+            M = m
+
+        # 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)
+
+        # Add closing coordinates to sequence?
+        if M > m:
+            coords = ob[0]
+            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, M-1, dx)
+            lgeos.GEOSCoordSeq_setY(cs, M-1, dy)
+            if n == 3:
+                lgeos.GEOSCoordSeq_setZ(cs, M-1, dz)
+
+    if update_geom is not None:
+        return None
+    else:
+        return lgeos.GEOSGeom_createLinearRing(cs), n
+
+def update_linearring_from_py(geom, ob):
+    geos_linearring_from_py(ob, geom._geom, geom._ndim)
+
+def geos_polygon_from_py(shell, holes=None):
+    if shell is not None:
+        geos_shell, ndim = geos_linearring_from_py(shell)
+        if holes:
+            ob = holes
+            L = len(ob)
+            exemplar = ob[0]
+            try:
+                N = len(exemplar[0])
+            except TypeError:
+                N = exemplar._ndim
+            assert L >= 1
+            assert N == 2 or N == 3
+
+            # Array of pointers to ring geometries
+            geos_holes = (c_void_p * L)()
+    
+            # add to coordinate sequence
+            for l in xrange(L):
+                geom, ndim = geos_linearring_from_py(ob[l])
+                geos_holes[l] = cast(geom, c_void_p)
+        else:
+            geos_holes = POINTER(c_void_p)()
+            L = 0
+        return (
+            lgeos.GEOSGeom_createPolygon(
+                        c_void_p(geos_shell),
+                        geos_holes,
+                        L
+                        ),
+            ndim
+            )
+
+# Test runner
+def _test():
+    import doctest
+    doctest.testmod()
+
+if __name__ == "__main__":
+    _test()