| """ |
| This module houses the Point, LineString, LinearRing, and Polygon OGC |
| geometry classes. All geometry classes in this module inherit from |
| GEOSGeometry. |
| """ |
| from ctypes import c_uint, byref |
| from django.contrib.gis.geos.base import GEOSGeometry |
| from django.contrib.gis.geos.coordseq import GEOSCoordSeq |
| from django.contrib.gis.geos.error import GEOSException, GEOSIndexError |
| from django.contrib.gis.geos.libgeos import get_pointer_arr, GEOM_PTR, HAS_NUMPY |
| from django.contrib.gis.geos.prototypes import * |
| if HAS_NUMPY: from numpy import ndarray, array |
| |
| class Point(GEOSGeometry): |
| |
| def __init__(self, x, y=None, z=None, srid=None): |
| """ |
| The Point object may be initialized with either a tuple, or individual |
| parameters. |
| |
| For Example: |
| >>> p = Point((5, 23)) # 2D point, passed in as a tuple |
| >>> p = Point(5, 23, 8) # 3D point, passed in with individual parameters |
| """ |
| |
| if isinstance(x, (tuple, list)): |
| # Here a tuple or list was passed in under the `x` parameter. |
| ndim = len(x) |
| if ndim < 2 or ndim > 3: |
| raise TypeError('Invalid sequence parameter: %s' % str(x)) |
| coords = x |
| elif isinstance(x, (int, float, long)) and isinstance(y, (int, float, long)): |
| # Here X, Y, and (optionally) Z were passed in individually, as parameters. |
| if isinstance(z, (int, float, long)): |
| ndim = 3 |
| coords = [x, y, z] |
| else: |
| ndim = 2 |
| coords = [x, y] |
| else: |
| raise TypeError('Invalid parameters given for Point initialization.') |
| |
| # Creating the coordinate sequence, and setting X, Y, [Z] |
| cs = create_cs(c_uint(1), c_uint(ndim)) |
| cs_setx(cs, 0, coords[0]) |
| cs_sety(cs, 0, coords[1]) |
| if ndim == 3: cs_setz(cs, 0, coords[2]) |
| |
| # Initializing using the address returned from the GEOS |
| # createPoint factory. |
| super(Point, self).__init__(create_point(cs), srid=srid) |
| |
| def __len__(self): |
| "Returns the number of dimensions for this Point (either 0, 2 or 3)." |
| if self.empty: return 0 |
| if self.hasz: return 3 |
| else: return 2 |
| |
| def get_x(self): |
| "Returns the X component of the Point." |
| return self._cs.getOrdinate(0, 0) |
| |
| def set_x(self, value): |
| "Sets the X component of the Point." |
| self._cs.setOrdinate(0, 0, value) |
| |
| def get_y(self): |
| "Returns the Y component of the Point." |
| return self._cs.getOrdinate(1, 0) |
| |
| def set_y(self, value): |
| "Sets the Y component of the Point." |
| self._cs.setOrdinate(1, 0, value) |
| |
| def get_z(self): |
| "Returns the Z component of the Point." |
| if self.hasz: |
| return self._cs.getOrdinate(2, 0) |
| else: |
| return None |
| |
| def set_z(self, value): |
| "Sets the Z component of the Point." |
| if self.hasz: |
| self._cs.setOrdinate(2, 0, value) |
| else: |
| raise GEOSException('Cannot set Z on 2D Point.') |
| |
| # X, Y, Z properties |
| x = property(get_x, set_x) |
| y = property(get_y, set_y) |
| z = property(get_z, set_z) |
| |
| ### Tuple setting and retrieval routines. ### |
| def get_coords(self): |
| "Returns a tuple of the point." |
| return self._cs.tuple |
| |
| def set_coords(self, tup): |
| "Sets the coordinates of the point with the given tuple." |
| self._cs[0] = tup |
| |
| # The tuple and coords properties |
| tuple = property(get_coords, set_coords) |
| coords = tuple |
| |
| class LineString(GEOSGeometry): |
| |
| #### Python 'magic' routines #### |
| def __init__(self, *args, **kwargs): |
| """ |
| Initializes on the given sequence -- may take lists, tuples, NumPy arrays |
| of X,Y pairs, or Point objects. If Point objects are used, ownership is |
| _not_ transferred to the LineString object. |
| |
| Examples: |
| ls = LineString((1, 1), (2, 2)) |
| ls = LineString([(1, 1), (2, 2)]) |
| ls = LineString(array([(1, 1), (2, 2)])) |
| ls = LineString(Point(1, 1), Point(2, 2)) |
| """ |
| # If only one argument provided, set the coords array appropriately |
| if len(args) == 1: coords = args[0] |
| else: coords = args |
| |
| if isinstance(coords, (tuple, list)): |
| # Getting the number of coords and the number of dimensions -- which |
| # must stay the same, e.g., no LineString((1, 2), (1, 2, 3)). |
| ncoords = len(coords) |
| if coords: ndim = len(coords[0]) |
| else: raise TypeError('Cannot initialize on empty sequence.') |
| self._checkdim(ndim) |
| # Incrementing through each of the coordinates and verifying |
| for i in xrange(1, ncoords): |
| if not isinstance(coords[i], (tuple, list, Point)): |
| raise TypeError('each coordinate should be a sequence (list or tuple)') |
| if len(coords[i]) != ndim: raise TypeError('Dimension mismatch.') |
| numpy_coords = False |
| elif HAS_NUMPY and isinstance(coords, ndarray): |
| shape = coords.shape # Using numpy's shape. |
| if len(shape) != 2: raise TypeError('Too many dimensions.') |
| self._checkdim(shape[1]) |
| ncoords = shape[0] |
| ndim = shape[1] |
| numpy_coords = True |
| else: |
| raise TypeError('Invalid initialization input for LineStrings.') |
| |
| # Creating a coordinate sequence object because it is easier to |
| # set the points using GEOSCoordSeq.__setitem__(). |
| cs = GEOSCoordSeq(create_cs(ncoords, ndim), z=bool(ndim==3)) |
| for i in xrange(ncoords): |
| if numpy_coords: cs[i] = coords[i,:] |
| elif isinstance(coords[i], Point): cs[i] = coords[i].tuple |
| else: cs[i] = coords[i] |
| |
| # Getting the correct initialization function |
| if kwargs.get('ring', False): |
| func = create_linearring |
| else: |
| func = create_linestring |
| |
| # If SRID was passed in with the keyword arguments |
| srid = kwargs.get('srid', None) |
| |
| # Calling the base geometry initialization with the returned pointer |
| # from the function. |
| super(LineString, self).__init__(func(cs.ptr), srid=srid) |
| |
| def __getitem__(self, index): |
| "Gets the point at the specified index." |
| return self._cs[index] |
| |
| def __setitem__(self, index, value): |
| "Sets the point at the specified index, e.g., line_str[0] = (1, 2)." |
| self._cs[index] = value |
| |
| def __iter__(self): |
| "Allows iteration over this LineString." |
| for i in xrange(len(self)): |
| yield self[i] |
| |
| def __len__(self): |
| "Returns the number of points in this LineString." |
| return len(self._cs) |
| |
| def _checkdim(self, dim): |
| if dim not in (2, 3): raise TypeError('Dimension mismatch.') |
| |
| #### Sequence Properties #### |
| @property |
| def tuple(self): |
| "Returns a tuple version of the geometry from the coordinate sequence." |
| return self._cs.tuple |
| coords = tuple |
| |
| def _listarr(self, func): |
| """ |
| Internal routine that returns a sequence (list) corresponding with |
| the given function. Will return a numpy array if possible. |
| """ |
| lst = [func(i) for i in xrange(len(self))] |
| if HAS_NUMPY: return array(lst) # ARRRR! |
| else: return lst |
| |
| @property |
| def array(self): |
| "Returns a numpy array for the LineString." |
| return self._listarr(self._cs.__getitem__) |
| |
| @property |
| def x(self): |
| "Returns a list or numpy array of the X variable." |
| return self._listarr(self._cs.getX) |
| |
| @property |
| def y(self): |
| "Returns a list or numpy array of the Y variable." |
| return self._listarr(self._cs.getY) |
| |
| @property |
| def z(self): |
| "Returns a list or numpy array of the Z variable." |
| if not self.hasz: return None |
| else: return self._listarr(self._cs.getZ) |
| |
| # LinearRings are LineStrings used within Polygons. |
| class LinearRing(LineString): |
| def __init__(self, *args, **kwargs): |
| "Overriding the initialization function to set the ring keyword." |
| kwargs['ring'] = True # Setting the ring keyword argument to True |
| super(LinearRing, self).__init__(*args, **kwargs) |
| |
| class Polygon(GEOSGeometry): |
| |
| def __init__(self, *args, **kwargs): |
| """ |
| Initializes on an exterior ring and a sequence of holes (both |
| instances may be either LinearRing instances, or a tuple/list |
| that may be constructed into a LinearRing). |
| |
| Examples of initialization, where shell, hole1, and hole2 are |
| valid LinearRing geometries: |
| >>> poly = Polygon(shell, hole1, hole2) |
| >>> poly = Polygon(shell, (hole1, hole2)) |
| |
| Example where a tuple parameters are used: |
| >>> poly = Polygon(((0, 0), (0, 10), (10, 10), (0, 10), (0, 0)), |
| ((4, 4), (4, 6), (6, 6), (6, 4), (4, 4))) |
| """ |
| if not args: |
| raise TypeError('Must provide at list one LinearRing instance to initialize Polygon.') |
| |
| # Getting the ext_ring and init_holes parameters from the argument list |
| ext_ring = args[0] |
| init_holes = args[1:] |
| n_holes = len(init_holes) |
| |
| # If initialized as Polygon(shell, (LinearRing, LinearRing)) [for backward-compatibility] |
| if n_holes == 1 and isinstance(init_holes[0], (tuple, list)) and \ |
| (len(init_holes[0]) == 0 or isinstance(init_holes[0][0], LinearRing)): |
| init_holes = init_holes[0] |
| n_holes = len(init_holes) |
| |
| # Ensuring the exterior ring and holes parameters are LinearRing objects |
| # or may be instantiated into LinearRings. |
| ext_ring = self._construct_ring(ext_ring, 'Exterior parameter must be a LinearRing or an object that can initialize a LinearRing.') |
| holes_list = [] # Create new list, cause init_holes is a tuple. |
| for i in xrange(n_holes): |
| holes_list.append(self._construct_ring(init_holes[i], 'Holes parameter must be a sequence of LinearRings or objects that can initialize to LinearRings')) |
| |
| # Why another loop? Because if a TypeError is raised, cloned pointers will |
| # be around that can't be cleaned up. |
| holes = get_pointer_arr(n_holes) |
| for i in xrange(n_holes): holes[i] = geom_clone(holes_list[i].ptr) |
| |
| # Getting the shell pointer address. |
| shell = geom_clone(ext_ring.ptr) |
| |
| # Calling with the GEOS createPolygon factory. |
| super(Polygon, self).__init__(create_polygon(shell, byref(holes), c_uint(n_holes)), **kwargs) |
| |
| def __getitem__(self, index): |
| """ |
| Returns the ring at the specified index. The first index, 0, will |
| always return the exterior ring. Indices > 0 will return the |
| interior ring at the given index (e.g., poly[1] and poly[2] would |
| return the first and second interior ring, respectively). |
| """ |
| if index == 0: |
| return self.exterior_ring |
| else: |
| # Getting the interior ring, have to subtract 1 from the index. |
| return self.get_interior_ring(index-1) |
| |
| def __setitem__(self, index, ring): |
| "Sets the ring at the specified index with the given ring." |
| # Checking the index and ring parameters. |
| self._checkindex(index) |
| if not isinstance(ring, LinearRing): |
| raise TypeError('must set Polygon index with a LinearRing object') |
| |
| # Getting the shell |
| if index == 0: |
| shell = geom_clone(ring.ptr) |
| else: |
| shell = geom_clone(get_extring(self.ptr)) |
| |
| # Getting the interior rings (holes) |
| nholes = len(self)-1 |
| if nholes > 0: |
| holes = get_pointer_arr(nholes) |
| for i in xrange(nholes): |
| if i == (index-1): |
| holes[i] = geom_clone(ring.ptr) |
| else: |
| holes[i] = geom_clone(get_intring(self.ptr, i)) |
| holes_param = byref(holes) |
| else: |
| holes_param = None |
| |
| # Getting the current pointer, replacing with the newly constructed |
| # geometry, and destroying the old geometry. |
| prev_ptr = self.ptr |
| srid = self.srid |
| self._ptr = create_polygon(shell, holes_param, c_uint(nholes)) |
| if srid: self.srid = srid |
| destroy_geom(prev_ptr) |
| |
| def __iter__(self): |
| "Iterates over each ring in the polygon." |
| for i in xrange(len(self)): |
| yield self[i] |
| |
| def __len__(self): |
| "Returns the number of rings in this Polygon." |
| return self.num_interior_rings + 1 |
| |
| def _checkindex(self, index): |
| "Internal routine for checking the given ring index." |
| if index < 0 or index >= len(self): |
| raise GEOSIndexError('invalid Polygon ring index: %s' % index) |
| |
| def _construct_ring(self, param, msg=''): |
| "Helper routine for trying to construct a ring from the given parameter." |
| if isinstance(param, LinearRing): return param |
| try: |
| ring = LinearRing(param) |
| return ring |
| except TypeError: |
| raise TypeError(msg) |
| |
| def get_interior_ring(self, ring_i): |
| """ |
| Gets the interior ring at the specified index, 0 is for the first |
| interior ring, not the exterior ring. |
| """ |
| self._checkindex(ring_i+1) |
| return GEOSGeometry(geom_clone(get_intring(self.ptr, ring_i)), srid=self.srid) |
| |
| #### Polygon Properties #### |
| @property |
| def num_interior_rings(self): |
| "Returns the number of interior rings." |
| # Getting the number of rings |
| return get_nrings(self.ptr) |
| |
| def get_ext_ring(self): |
| "Gets the exterior ring of the Polygon." |
| return GEOSGeometry(geom_clone(get_extring(self.ptr)), srid=self.srid) |
| |
| def set_ext_ring(self, ring): |
| "Sets the exterior ring of the Polygon." |
| self[0] = ring |
| |
| # properties for the exterior ring/shell |
| exterior_ring = property(get_ext_ring, set_ext_ring) |
| shell = exterior_ring |
| |
| @property |
| def tuple(self): |
| "Gets the tuple for each ring in this Polygon." |
| return tuple([self[i].tuple for i in xrange(len(self))]) |
| coords = tuple |
| |
| @property |
| def kml(self): |
| "Returns the KML representation of this Polygon." |
| inner_kml = ''.join(["<innerBoundaryIs>%s</innerBoundaryIs>" % self[i+1].kml |
| for i in xrange(self.num_interior_rings)]) |
| return "<Polygon><outerBoundaryIs>%s</outerBoundaryIs>%s</Polygon>" % (self[0].kml, inner_kml) |
