| from ctypes import c_uint, byref |
| from django.contrib.gis.geos.error import GEOSIndexError |
| from django.contrib.gis.geos.geometry import GEOSGeometry |
| from django.contrib.gis.geos.libgeos import get_pointer_arr, GEOM_PTR |
| from django.contrib.gis.geos.linestring import LinearRing |
| from django.contrib.gis.geos import prototypes as capi |
| |
| class Polygon(GEOSGeometry): |
| _minlength = 1 |
| |
| 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 least one LinearRing, or a tuple, to initialize a 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)): |
| if len(init_holes[0]) == 0: |
| init_holes = () |
| n_holes = 0 |
| elif isinstance(init_holes[0][0], LinearRing): |
| init_holes = init_holes[0] |
| n_holes = len(init_holes) |
| |
| polygon = self._create_polygon(n_holes + 1, (ext_ring,) + init_holes) |
| super(Polygon, self).__init__(polygon, **kwargs) |
| |
| 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 |
| |
| @classmethod |
| def from_bbox(cls, bbox): |
| "Constructs a Polygon from a bounding box (4-tuple)." |
| x0, y0, x1, y1 = bbox |
| return GEOSGeometry( 'POLYGON((%s %s, %s %s, %s %s, %s %s, %s %s))' % ( |
| x0, y0, x0, y1, x1, y1, x1, y0, x0, y0) ) |
| |
| ### These routines are needed for list-like operation w/ListMixin ### |
| def _create_polygon(self, length, items): |
| # Instantiate LinearRing objects if necessary, but don't clone them yet |
| # _construct_ring will throw a TypeError if a parameter isn't a valid ring |
| # If we cloned the pointers here, we wouldn't be able to clean up |
| # in case of error. |
| rings = [] |
| for r in items: |
| if isinstance(r, GEOM_PTR): |
| rings.append(r) |
| else: |
| rings.append(self._construct_ring(r)) |
| |
| shell = self._clone(rings.pop(0)) |
| |
| n_holes = length - 1 |
| if n_holes: |
| holes = get_pointer_arr(n_holes) |
| for i, r in enumerate(rings): |
| holes[i] = self._clone(r) |
| holes_param = byref(holes) |
| else: |
| holes_param = None |
| |
| return capi.create_polygon(shell, holes_param, c_uint(n_holes)) |
| |
| def _clone(self, g): |
| if isinstance(g, GEOM_PTR): |
| return capi.geom_clone(g) |
| else: |
| return capi.geom_clone(g.ptr) |
| |
| def _construct_ring(self, param, msg='Parameter must be a sequence of LinearRings or objects that can initialize to LinearRings'): |
| "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 _set_list(self, length, items): |
| # Getting the current pointer, replacing with the newly constructed |
| # geometry, and destroying the old geometry. |
| prev_ptr = self.ptr |
| srid = self.srid |
| self.ptr = self._create_polygon(length, items) |
| if srid: self.srid = srid |
| capi.destroy_geom(prev_ptr) |
| |
| def _get_single_internal(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). |
| |
| CAREFUL: Internal/External are not the same as Interior/Exterior! |
| _get_single_internal returns a pointer from the existing geometries for use |
| internally by the object's methods. _get_single_external returns a clone |
| of the same geometry for use by external code. |
| """ |
| if index == 0: |
| return capi.get_extring(self.ptr) |
| else: |
| # Getting the interior ring, have to subtract 1 from the index. |
| return capi.get_intring(self.ptr, index-1) |
| |
| def _get_single_external(self, index): |
| return GEOSGeometry(capi.geom_clone(self._get_single_internal(index)), srid=self.srid) |
| |
| _set_single = GEOSGeometry._set_single_rebuild |
| _assign_extended_slice = GEOSGeometry._assign_extended_slice_rebuild |
| |
| #### Polygon Properties #### |
| @property |
| def num_interior_rings(self): |
| "Returns the number of interior rings." |
| # Getting the number of rings |
| return capi.get_nrings(self.ptr) |
| |
| def _get_ext_ring(self): |
| "Gets the exterior ring of the Polygon." |
| return self[0] |
| |
| 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) |
