diff options
Diffstat (limited to 'lib/python2.7/site-packages/django/contrib/gis/geos')
29 files changed, 4726 insertions, 0 deletions
diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/geos/__init__.py new file mode 100644 index 0000000..945f561 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/__init__.py @@ -0,0 +1,20 @@ +""" +The GeoDjango GEOS module. Please consult the GeoDjango documentation +for more details: + http://geodjango.org/docs/geos.html +""" +try: + from .libgeos import geos_version, geos_version_info, GEOS_PREPARE + HAS_GEOS = True +except ImportError: + HAS_GEOS = False + +if HAS_GEOS: + from .geometry import GEOSGeometry, wkt_regex, hex_regex + from .point import Point + from .linestring import LineString, LinearRing + from .polygon import Polygon + from .collections import GeometryCollection, MultiPoint, MultiLineString, MultiPolygon + from .error import GEOSException, GEOSIndexError + from .io import WKTReader, WKTWriter, WKBReader, WKBWriter + from .factory import fromfile, fromstr diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/base.py b/lib/python2.7/site-packages/django/contrib/gis/geos/base.py new file mode 100644 index 0000000..fd2693e --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/base.py @@ -0,0 +1,51 @@ +from ctypes import c_void_p + +from django.contrib.gis.geos.error import GEOSException + +# Trying to import GDAL libraries, if available. Have to place in +# try/except since this package may be used outside GeoDjango. +try: + from django.contrib.gis import gdal +except ImportError: + # A 'dummy' gdal module. + class GDALInfo(object): + HAS_GDAL = False + gdal = GDALInfo() + +# NumPy supported? +try: + import numpy +except ImportError: + numpy = False + +class GEOSBase(object): + """ + Base object for GEOS objects that has a pointer access property + that controls access to the underlying C pointer. + """ + # Initially the pointer is NULL. + _ptr = None + + # Default allowed pointer type. + ptr_type = c_void_p + + # Pointer access property. + def _get_ptr(self): + # Raise an exception if the pointer isn't valid don't + # want to be passing NULL pointers to routines -- + # that's very bad. + if self._ptr: return self._ptr + else: raise GEOSException('NULL GEOS %s pointer encountered.' % self.__class__.__name__) + + def _set_ptr(self, ptr): + # Only allow the pointer to be set with pointers of the + # compatible type or None (NULL). + if ptr is None or isinstance(ptr, self.ptr_type): + self._ptr = ptr + else: + raise TypeError('Incompatible pointer type') + + # Property for controlling access to the GEOS object pointers. Using + # this raises an exception when the pointer is NULL, thus preventing + # the C library from attempting to access an invalid memory location. + ptr = property(_get_ptr, _set_ptr) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/collections.py b/lib/python2.7/site-packages/django/contrib/gis/geos/collections.py new file mode 100644 index 0000000..2b62bce --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/collections.py @@ -0,0 +1,124 @@ +""" + This module houses the Geometry Collection objects: + GeometryCollection, MultiPoint, MultiLineString, and MultiPolygon +""" +from ctypes import c_int, c_uint, byref +from django.contrib.gis.geos.error import GEOSException +from django.contrib.gis.geos.geometry import GEOSGeometry +from django.contrib.gis.geos.libgeos import get_pointer_arr, GEOS_PREPARE +from django.contrib.gis.geos.linestring import LineString, LinearRing +from django.contrib.gis.geos.point import Point +from django.contrib.gis.geos.polygon import Polygon +from django.contrib.gis.geos import prototypes as capi +from django.utils.six.moves import xrange + +class GeometryCollection(GEOSGeometry): + _typeid = 7 + + def __init__(self, *args, **kwargs): + "Initializes a Geometry Collection from a sequence of Geometry objects." + + # Checking the arguments + if not args: + raise TypeError('Must provide at least one Geometry to initialize %s.' % self.__class__.__name__) + + if len(args) == 1: + # If only one geometry provided or a list of geometries is provided + # in the first argument. + if isinstance(args[0], (tuple, list)): + init_geoms = args[0] + else: + init_geoms = args + else: + init_geoms = args + + # Ensuring that only the permitted geometries are allowed in this collection + # this is moved to list mixin super class + self._check_allowed(init_geoms) + + # Creating the geometry pointer array. + collection = self._create_collection(len(init_geoms), iter(init_geoms)) + super(GeometryCollection, self).__init__(collection, **kwargs) + + def __iter__(self): + "Iterates over each Geometry in the Collection." + for i in xrange(len(self)): + yield self[i] + + def __len__(self): + "Returns the number of geometries in this Collection." + return self.num_geom + + ### Methods for compatibility with ListMixin ### + def _create_collection(self, length, items): + # Creating the geometry pointer array. + geoms = get_pointer_arr(length) + for i, g in enumerate(items): + # this is a little sloppy, but makes life easier + # allow GEOSGeometry types (python wrappers) or pointer types + geoms[i] = capi.geom_clone(getattr(g, 'ptr', g)) + + return capi.create_collection(c_int(self._typeid), byref(geoms), c_uint(length)) + + def _get_single_internal(self, index): + return capi.get_geomn(self.ptr, index) + + def _get_single_external(self, index): + "Returns the Geometry from this Collection at the given index (0-based)." + # Checking the index and returning the corresponding GEOS geometry. + return GEOSGeometry(capi.geom_clone(self._get_single_internal(index)), srid=self.srid) + + def _set_list(self, length, items): + "Create a new collection, and destroy the contents of the previous pointer." + prev_ptr = self.ptr + srid = self.srid + self.ptr = self._create_collection(length, items) + if srid: self.srid = srid + capi.destroy_geom(prev_ptr) + + _set_single = GEOSGeometry._set_single_rebuild + _assign_extended_slice = GEOSGeometry._assign_extended_slice_rebuild + + @property + def kml(self): + "Returns the KML for this Geometry Collection." + return '<MultiGeometry>%s</MultiGeometry>' % ''.join([g.kml for g in self]) + + @property + def tuple(self): + "Returns a tuple of all the coordinates in this Geometry Collection" + return tuple([g.tuple for g in self]) + coords = tuple + +# MultiPoint, MultiLineString, and MultiPolygon class definitions. +class MultiPoint(GeometryCollection): + _allowed = Point + _typeid = 4 + +class MultiLineString(GeometryCollection): + _allowed = (LineString, LinearRing) + _typeid = 5 + + @property + def merged(self): + """ + Returns a LineString representing the line merge of this + MultiLineString. + """ + return self._topology(capi.geos_linemerge(self.ptr)) + +class MultiPolygon(GeometryCollection): + _allowed = Polygon + _typeid = 6 + + @property + def cascaded_union(self): + "Returns a cascaded union of this MultiPolygon." + if GEOS_PREPARE: + return GEOSGeometry(capi.geos_cascaded_union(self.ptr), self.srid) + else: + raise GEOSException('The cascaded union operation requires GEOS 3.1+.') + +# Setting the allowed types here since GeometryCollection is defined before +# its subclasses. +GeometryCollection._allowed = (Point, LineString, LinearRing, Polygon, MultiPoint, MultiLineString, MultiPolygon) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/coordseq.py b/lib/python2.7/site-packages/django/contrib/gis/geos/coordseq.py new file mode 100644 index 0000000..acf34f7 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/coordseq.py @@ -0,0 +1,157 @@ +""" + This module houses the GEOSCoordSeq object, which is used internally + by GEOSGeometry to house the actual coordinates of the Point, + LineString, and LinearRing geometries. +""" +from ctypes import c_double, c_uint, byref +from django.contrib.gis.geos.base import GEOSBase, numpy +from django.contrib.gis.geos.error import GEOSException, GEOSIndexError +from django.contrib.gis.geos.libgeos import CS_PTR +from django.contrib.gis.geos import prototypes as capi +from django.utils.six.moves import xrange + +class GEOSCoordSeq(GEOSBase): + "The internal representation of a list of coordinates inside a Geometry." + + ptr_type = CS_PTR + + #### Python 'magic' routines #### + def __init__(self, ptr, z=False): + "Initializes from a GEOS pointer." + if not isinstance(ptr, CS_PTR): + raise TypeError('Coordinate sequence should initialize with a CS_PTR.') + self._ptr = ptr + self._z = z + + def __iter__(self): + "Iterates over each point in the coordinate sequence." + for i in xrange(self.size): + yield self[i] + + def __len__(self): + "Returns the number of points in the coordinate sequence." + return int(self.size) + + def __str__(self): + "Returns the string representation of the coordinate sequence." + return str(self.tuple) + + def __getitem__(self, index): + "Returns the coordinate sequence value at the given index." + coords = [self.getX(index), self.getY(index)] + if self.dims == 3 and self._z: + coords.append(self.getZ(index)) + return tuple(coords) + + def __setitem__(self, index, value): + "Sets the coordinate sequence value at the given index." + # Checking the input value + if isinstance(value, (list, tuple)): + pass + elif numpy and isinstance(value, numpy.ndarray): + pass + else: + raise TypeError('Must set coordinate with a sequence (list, tuple, or numpy array).') + # Checking the dims of the input + if self.dims == 3 and self._z: + n_args = 3 + set_3d = True + else: + n_args = 2 + set_3d = False + if len(value) != n_args: + raise TypeError('Dimension of value does not match.') + # Setting the X, Y, Z + self.setX(index, value[0]) + self.setY(index, value[1]) + if set_3d: self.setZ(index, value[2]) + + #### Internal Routines #### + def _checkindex(self, index): + "Checks the given index." + sz = self.size + if (sz < 1) or (index < 0) or (index >= sz): + raise GEOSIndexError('invalid GEOS Geometry index: %s' % str(index)) + + def _checkdim(self, dim): + "Checks the given dimension." + if dim < 0 or dim > 2: + raise GEOSException('invalid ordinate dimension "%d"' % dim) + + #### Ordinate getting and setting routines #### + def getOrdinate(self, dimension, index): + "Returns the value for the given dimension and index." + self._checkindex(index) + self._checkdim(dimension) + return capi.cs_getordinate(self.ptr, index, dimension, byref(c_double())) + + def setOrdinate(self, dimension, index, value): + "Sets the value for the given dimension and index." + self._checkindex(index) + self._checkdim(dimension) + capi.cs_setordinate(self.ptr, index, dimension, value) + + def getX(self, index): + "Get the X value at the index." + return self.getOrdinate(0, index) + + def setX(self, index, value): + "Set X with the value at the given index." + self.setOrdinate(0, index, value) + + def getY(self, index): + "Get the Y value at the given index." + return self.getOrdinate(1, index) + + def setY(self, index, value): + "Set Y with the value at the given index." + self.setOrdinate(1, index, value) + + def getZ(self, index): + "Get Z with the value at the given index." + return self.getOrdinate(2, index) + + def setZ(self, index, value): + "Set Z with the value at the given index." + self.setOrdinate(2, index, value) + + ### Dimensions ### + @property + def size(self): + "Returns the size of this coordinate sequence." + return capi.cs_getsize(self.ptr, byref(c_uint())) + + @property + def dims(self): + "Returns the dimensions of this coordinate sequence." + return capi.cs_getdims(self.ptr, byref(c_uint())) + + @property + def hasz(self): + """ + Returns whether this coordinate sequence is 3D. This property value is + inherited from the parent Geometry. + """ + return self._z + + ### Other Methods ### + def clone(self): + "Clones this coordinate sequence." + return GEOSCoordSeq(capi.cs_clone(self.ptr), self.hasz) + + @property + def kml(self): + "Returns the KML representation for the coordinates." + # Getting the substitution string depending on whether the coordinates have + # a Z dimension. + if self.hasz: substr = '%s,%s,%s ' + else: substr = '%s,%s,0 ' + return '<coordinates>%s</coordinates>' % \ + ''.join([substr % self[i] for i in xrange(len(self))]).strip() + + @property + def tuple(self): + "Returns a tuple version of this coordinate sequence." + n = self.size + if n == 1: return self[0] + else: return tuple([self[i] for i in xrange(n)]) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/error.py b/lib/python2.7/site-packages/django/contrib/gis/geos/error.py new file mode 100644 index 0000000..46bdfe6 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/error.py @@ -0,0 +1,20 @@ +""" + This module houses the GEOS exceptions, specifically, GEOSException and + GEOSGeometryIndexError. +""" + +class GEOSException(Exception): + "The base GEOS exception, indicates a GEOS-related error." + pass + +class GEOSIndexError(GEOSException, KeyError): + """ + This exception is raised when an invalid index is encountered, and has + the 'silent_variable_feature' attribute set to true. This ensures that + django's templates proceed to use the next lookup type gracefully when + an Exception is raised. Fixes ticket #4740. + """ + # "If, during the method lookup, a method raises an exception, the exception + # will be propagated, unless the exception has an attribute + # `silent_variable_failure` whose value is True." -- Django template docs. + silent_variable_failure = True diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/factory.py b/lib/python2.7/site-packages/django/contrib/gis/geos/factory.py new file mode 100644 index 0000000..2e5fa4f --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/factory.py @@ -0,0 +1,35 @@ +from django.contrib.gis import memoryview +from django.contrib.gis.geos.geometry import GEOSGeometry, wkt_regex, hex_regex + +from django.utils import six + + +def fromfile(file_h): + """ + Given a string file name, returns a GEOSGeometry. The file may contain WKB, + WKT, or HEX. + """ + # If given a file name, get a real handle. + if isinstance(file_h, six.string_types): + with open(file_h, 'rb') as file_h: + buf = file_h.read() + else: + buf = file_h.read() + + # If we get WKB need to wrap in memoryview(), so run through regexes. + if isinstance(buf, bytes): + try: + decoded = buf.decode() + if wkt_regex.match(decoded) or hex_regex.match(decoded): + return GEOSGeometry(decoded) + except UnicodeDecodeError: + pass + else: + return GEOSGeometry(buf) + + return GEOSGeometry(memoryview(buf)) + + +def fromstr(string, **kwargs): + "Given a string value, returns a GEOSGeometry object." + return GEOSGeometry(string, **kwargs) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/geometry.py b/lib/python2.7/site-packages/django/contrib/gis/geos/geometry.py new file mode 100644 index 0000000..b088ec2 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/geometry.py @@ -0,0 +1,715 @@ +""" + This module contains the 'base' GEOSGeometry object -- all GEOS Geometries + inherit from this object. +""" +from __future__ import unicode_literals + +# Python, ctypes and types dependencies. +from ctypes import addressof, byref, c_double + +from django.contrib.gis import memoryview +# super-class for mutable list behavior +from django.contrib.gis.geos.mutable_list import ListMixin + +from django.contrib.gis.gdal.error import SRSException + +# GEOS-related dependencies. +from django.contrib.gis.geos.base import GEOSBase, gdal +from django.contrib.gis.geos.coordseq import GEOSCoordSeq +from django.contrib.gis.geos.error import GEOSException, GEOSIndexError +from django.contrib.gis.geos.libgeos import GEOM_PTR, GEOS_PREPARE +from django.contrib.gis.geos.mutable_list import ListMixin + +# All other functions in this module come from the ctypes +# prototypes module -- which handles all interaction with +# the underlying GEOS library. +from django.contrib.gis.geos import prototypes as capi + +# These functions provide access to a thread-local instance +# of their corresponding GEOS I/O class. +from django.contrib.gis.geos.prototypes.io import wkt_r, wkt_w, wkb_r, wkb_w, ewkb_w + +# For recognizing geometry input. +from django.contrib.gis.geometry.regex import hex_regex, wkt_regex, json_regex + +from django.utils import six +from django.utils.encoding import force_bytes, force_text + + +class GEOSGeometry(GEOSBase, ListMixin): + "A class that, generally, encapsulates a GEOS geometry." + + # Raise GEOSIndexError instead of plain IndexError + # (see ticket #4740 and GEOSIndexError docstring) + _IndexError = GEOSIndexError + + ptr_type = GEOM_PTR + + #### Python 'magic' routines #### + def __init__(self, geo_input, srid=None): + """ + The base constructor for GEOS geometry objects, and may take the + following inputs: + + * strings: + - WKT + - HEXEWKB (a PostGIS-specific canonical form) + - GeoJSON (requires GDAL) + * buffer: + - WKB + + The `srid` keyword is used to specify the Source Reference Identifier + (SRID) number for this Geometry. If not set, the SRID will be None. + """ + if isinstance(geo_input, bytes): + geo_input = force_text(geo_input) + if isinstance(geo_input, six.string_types): + wkt_m = wkt_regex.match(geo_input) + if wkt_m: + # Handling WKT input. + if wkt_m.group('srid'): srid = int(wkt_m.group('srid')) + g = wkt_r().read(force_bytes(wkt_m.group('wkt'))) + elif hex_regex.match(geo_input): + # Handling HEXEWKB input. + g = wkb_r().read(force_bytes(geo_input)) + elif gdal.HAS_GDAL and json_regex.match(geo_input): + # Handling GeoJSON input. + g = wkb_r().read(gdal.OGRGeometry(geo_input).wkb) + else: + raise ValueError('String or unicode input unrecognized as WKT EWKT, and HEXEWKB.') + elif isinstance(geo_input, GEOM_PTR): + # When the input is a pointer to a geomtry (GEOM_PTR). + g = geo_input + elif isinstance(geo_input, memoryview): + # When the input is a buffer (WKB). + g = wkb_r().read(geo_input) + elif isinstance(geo_input, GEOSGeometry): + g = capi.geom_clone(geo_input.ptr) + else: + # Invalid geometry type. + raise TypeError('Improper geometry input type: %s' % str(type(geo_input))) + + if bool(g): + # Setting the pointer object with a valid pointer. + self.ptr = g + else: + raise GEOSException('Could not initialize GEOS Geometry with given input.') + + # Post-initialization setup. + self._post_init(srid) + + def _post_init(self, srid): + "Helper routine for performing post-initialization setup." + # Setting the SRID, if given. + if srid and isinstance(srid, int): self.srid = srid + + # Setting the class type (e.g., Point, Polygon, etc.) + self.__class__ = GEOS_CLASSES[self.geom_typeid] + + # Setting the coordinate sequence for the geometry (will be None on + # geometries that do not have coordinate sequences) + self._set_cs() + + def __del__(self): + """ + Destroys this Geometry; in other words, frees the memory used by the + GEOS C++ object. + """ + if self._ptr: capi.destroy_geom(self._ptr) + + def __copy__(self): + """ + Returns a clone because the copy of a GEOSGeometry may contain an + invalid pointer location if the original is garbage collected. + """ + return self.clone() + + def __deepcopy__(self, memodict): + """ + The `deepcopy` routine is used by the `Node` class of django.utils.tree; + thus, the protocol routine needs to be implemented to return correct + copies (clones) of these GEOS objects, which use C pointers. + """ + return self.clone() + + def __str__(self): + "WKT is used for the string representation." + return self.wkt + + def __repr__(self): + "Short-hand representation because WKT may be very large." + return '<%s object at %s>' % (self.geom_type, hex(addressof(self.ptr))) + + # Pickling support + def __getstate__(self): + # The pickled state is simply a tuple of the WKB (in string form) + # and the SRID. + return bytes(self.wkb), self.srid + + def __setstate__(self, state): + # Instantiating from the tuple state that was pickled. + wkb, srid = state + ptr = wkb_r().read(memoryview(wkb)) + if not ptr: raise GEOSException('Invalid Geometry loaded from pickled state.') + self.ptr = ptr + self._post_init(srid) + + # Comparison operators + def __eq__(self, other): + """ + Equivalence testing, a Geometry may be compared with another Geometry + or a WKT representation. + """ + if isinstance(other, six.string_types): + return self.wkt == other + elif isinstance(other, GEOSGeometry): + return self.equals_exact(other) + else: + return False + + def __ne__(self, other): + "The not equals operator." + return not (self == other) + + ### Geometry set-like operations ### + # Thanks to Sean Gillies for inspiration: + # http://lists.gispython.org/pipermail/community/2007-July/001034.html + # g = g1 | g2 + def __or__(self, other): + "Returns the union of this Geometry and the other." + return self.union(other) + + # g = g1 & g2 + def __and__(self, other): + "Returns the intersection of this Geometry and the other." + return self.intersection(other) + + # g = g1 - g2 + def __sub__(self, other): + "Return the difference this Geometry and the other." + return self.difference(other) + + # g = g1 ^ g2 + def __xor__(self, other): + "Return the symmetric difference of this Geometry and the other." + return self.sym_difference(other) + + #### Coordinate Sequence Routines #### + @property + def has_cs(self): + "Returns True if this Geometry has a coordinate sequence, False if not." + # Only these geometries are allowed to have coordinate sequences. + if isinstance(self, (Point, LineString, LinearRing)): + return True + else: + return False + + def _set_cs(self): + "Sets the coordinate sequence for this Geometry." + if self.has_cs: + self._cs = GEOSCoordSeq(capi.get_cs(self.ptr), self.hasz) + else: + self._cs = None + + @property + def coord_seq(self): + "Returns a clone of the coordinate sequence for this Geometry." + if self.has_cs: + return self._cs.clone() + + #### Geometry Info #### + @property + def geom_type(self): + "Returns a string representing the Geometry type, e.g. 'Polygon'" + return capi.geos_type(self.ptr).decode() + + @property + def geom_typeid(self): + "Returns an integer representing the Geometry type." + return capi.geos_typeid(self.ptr) + + @property + def num_geom(self): + "Returns the number of geometries in the Geometry." + return capi.get_num_geoms(self.ptr) + + @property + def num_coords(self): + "Returns the number of coordinates in the Geometry." + return capi.get_num_coords(self.ptr) + + @property + def num_points(self): + "Returns the number points, or coordinates, in the Geometry." + return self.num_coords + + @property + def dims(self): + "Returns the dimension of this Geometry (0=point, 1=line, 2=surface)." + return capi.get_dims(self.ptr) + + def normalize(self): + "Converts this Geometry to normal form (or canonical form)." + return capi.geos_normalize(self.ptr) + + #### Unary predicates #### + @property + def empty(self): + """ + Returns a boolean indicating whether the set of points in this Geometry + are empty. + """ + return capi.geos_isempty(self.ptr) + + @property + def hasz(self): + "Returns whether the geometry has a 3D dimension." + return capi.geos_hasz(self.ptr) + + @property + def ring(self): + "Returns whether or not the geometry is a ring." + return capi.geos_isring(self.ptr) + + @property + def simple(self): + "Returns false if the Geometry not simple." + return capi.geos_issimple(self.ptr) + + @property + def valid(self): + "This property tests the validity of this Geometry." + return capi.geos_isvalid(self.ptr) + + @property + def valid_reason(self): + """ + Returns a string containing the reason for any invalidity. + """ + if not GEOS_PREPARE: + raise GEOSException('Upgrade GEOS to 3.1 to get validity reason.') + return capi.geos_isvalidreason(self.ptr).decode() + + #### Binary predicates. #### + def contains(self, other): + "Returns true if other.within(this) returns true." + return capi.geos_contains(self.ptr, other.ptr) + + def crosses(self, other): + """ + Returns true if the DE-9IM intersection matrix for the two Geometries + is T*T****** (for a point and a curve,a point and an area or a line and + an area) 0******** (for two curves). + """ + return capi.geos_crosses(self.ptr, other.ptr) + + def disjoint(self, other): + """ + Returns true if the DE-9IM intersection matrix for the two Geometries + is FF*FF****. + """ + return capi.geos_disjoint(self.ptr, other.ptr) + + def equals(self, other): + """ + Returns true if the DE-9IM intersection matrix for the two Geometries + is T*F**FFF*. + """ + return capi.geos_equals(self.ptr, other.ptr) + + def equals_exact(self, other, tolerance=0): + """ + Returns true if the two Geometries are exactly equal, up to a + specified tolerance. + """ + return capi.geos_equalsexact(self.ptr, other.ptr, float(tolerance)) + + def intersects(self, other): + "Returns true if disjoint returns false." + return capi.geos_intersects(self.ptr, other.ptr) + + def overlaps(self, other): + """ + Returns true if the DE-9IM intersection matrix for the two Geometries + is T*T***T** (for two points or two surfaces) 1*T***T** (for two curves). + """ + return capi.geos_overlaps(self.ptr, other.ptr) + + def relate_pattern(self, other, pattern): + """ + Returns true if the elements in the DE-9IM intersection matrix for the + two Geometries match the elements in pattern. + """ + if not isinstance(pattern, six.string_types) or len(pattern) > 9: + raise GEOSException('invalid intersection matrix pattern') + return capi.geos_relatepattern(self.ptr, other.ptr, force_bytes(pattern)) + + def touches(self, other): + """ + Returns true if the DE-9IM intersection matrix for the two Geometries + is FT*******, F**T***** or F***T****. + """ + return capi.geos_touches(self.ptr, other.ptr) + + def within(self, other): + """ + Returns true if the DE-9IM intersection matrix for the two Geometries + is T*F**F***. + """ + return capi.geos_within(self.ptr, other.ptr) + + #### SRID Routines #### + def get_srid(self): + "Gets the SRID for the geometry, returns None if no SRID is set." + s = capi.geos_get_srid(self.ptr) + if s == 0: return None + else: return s + + def set_srid(self, srid): + "Sets the SRID for the geometry." + capi.geos_set_srid(self.ptr, srid) + srid = property(get_srid, set_srid) + + #### Output Routines #### + @property + def ewkt(self): + """ + Returns the EWKT (WKT + SRID) of the Geometry. Note that Z values + are *not* included in this representation because GEOS does not yet + support serializing them. + """ + if self.get_srid(): return 'SRID=%s;%s' % (self.srid, self.wkt) + else: return self.wkt + + @property + def wkt(self): + "Returns the WKT (Well-Known Text) representation of this Geometry." + return wkt_w(3 if self.hasz else 2).write(self).decode() + + @property + def hex(self): + """ + Returns the WKB of this Geometry in hexadecimal form. Please note + that the SRID is not included in this representation because it is not + a part of the OGC specification (use the `hexewkb` property instead). + """ + # A possible faster, all-python, implementation: + # str(self.wkb).encode('hex') + return wkb_w(3 if self.hasz else 2).write_hex(self) + + @property + def hexewkb(self): + """ + Returns the EWKB of this Geometry in hexadecimal form. This is an + extension of the WKB specification that includes SRID value that are + a part of this geometry. + """ + if self.hasz and not GEOS_PREPARE: + # See: http://trac.osgeo.org/geos/ticket/216 + raise GEOSException('Upgrade GEOS to 3.1 to get valid 3D HEXEWKB.') + return ewkb_w(3 if self.hasz else 2).write_hex(self) + + @property + def json(self): + """ + Returns GeoJSON representation of this Geometry if GDAL is installed. + """ + if gdal.HAS_GDAL: + return self.ogr.json + else: + raise GEOSException('GeoJSON output only supported when GDAL is installed.') + geojson = json + + @property + def wkb(self): + """ + Returns the WKB (Well-Known Binary) representation of this Geometry + as a Python buffer. SRID and Z values are not included, use the + `ewkb` property instead. + """ + return wkb_w(3 if self.hasz else 2).write(self) + + @property + def ewkb(self): + """ + Return the EWKB representation of this Geometry as a Python buffer. + This is an extension of the WKB specification that includes any SRID + value that are a part of this geometry. + """ + if self.hasz and not GEOS_PREPARE: + # See: http://trac.osgeo.org/geos/ticket/216 + raise GEOSException('Upgrade GEOS to 3.1 to get valid 3D EWKB.') + return ewkb_w(3 if self.hasz else 2).write(self) + + @property + def kml(self): + "Returns the KML representation of this Geometry." + gtype = self.geom_type + return '<%s>%s</%s>' % (gtype, self.coord_seq.kml, gtype) + + @property + def prepared(self): + """ + Returns a PreparedGeometry corresponding to this geometry -- it is + optimized for the contains, intersects, and covers operations. + """ + if GEOS_PREPARE: + return PreparedGeometry(self) + else: + raise GEOSException('GEOS 3.1+ required for prepared geometry support.') + + #### GDAL-specific output routines #### + @property + def ogr(self): + "Returns the OGR Geometry for this Geometry." + if not gdal.HAS_GDAL: + raise GEOSException('GDAL required to convert to an OGRGeometry.') + if self.srid: + try: + return gdal.OGRGeometry(self.wkb, self.srid) + except SRSException: + pass + return gdal.OGRGeometry(self.wkb) + + @property + def srs(self): + "Returns the OSR SpatialReference for SRID of this Geometry." + if not gdal.HAS_GDAL: + raise GEOSException('GDAL required to return a SpatialReference object.') + if self.srid: + try: + return gdal.SpatialReference(self.srid) + except SRSException: + pass + return None + + @property + def crs(self): + "Alias for `srs` property." + return self.srs + + def transform(self, ct, clone=False): + """ + Requires GDAL. Transforms the geometry according to the given + transformation object, which may be an integer SRID, and WKT or + PROJ.4 string. By default, the geometry is transformed in-place and + nothing is returned. However if the `clone` keyword is set, then this + geometry will not be modified and a transformed clone will be returned + instead. + """ + srid = self.srid + + if ct == srid: + # short-circuit where source & dest SRIDs match + if clone: + return self.clone() + else: + return + + if (srid is None) or (srid < 0): + raise GEOSException("Calling transform() with no SRID set is not supported") + + if not gdal.HAS_GDAL: + raise GEOSException("GDAL library is not available to transform() geometry.") + + # Creating an OGR Geometry, which is then transformed. + g = self.ogr + g.transform(ct) + # Getting a new GEOS pointer + ptr = wkb_r().read(g.wkb) + if clone: + # User wants a cloned transformed geometry returned. + return GEOSGeometry(ptr, srid=g.srid) + if ptr: + # Reassigning pointer, and performing post-initialization setup + # again due to the reassignment. + capi.destroy_geom(self.ptr) + self.ptr = ptr + self._post_init(g.srid) + else: + raise GEOSException('Transformed WKB was invalid.') + + #### Topology Routines #### + def _topology(self, gptr): + "Helper routine to return Geometry from the given pointer." + return GEOSGeometry(gptr, srid=self.srid) + + @property + def boundary(self): + "Returns the boundary as a newly allocated Geometry object." + return self._topology(capi.geos_boundary(self.ptr)) + + def buffer(self, width, quadsegs=8): + """ + Returns a geometry that represents all points whose distance from this + Geometry is less than or equal to distance. Calculations are in the + Spatial Reference System of this Geometry. The optional third parameter sets + the number of segment used to approximate a quarter circle (defaults to 8). + (Text from PostGIS documentation at ch. 6.1.3) + """ + return self._topology(capi.geos_buffer(self.ptr, width, quadsegs)) + + @property + def centroid(self): + """ + The centroid is equal to the centroid of the set of component Geometries + of highest dimension (since the lower-dimension geometries contribute zero + "weight" to the centroid). + """ + return self._topology(capi.geos_centroid(self.ptr)) + + @property + def convex_hull(self): + """ + Returns the smallest convex Polygon that contains all the points + in the Geometry. + """ + return self._topology(capi.geos_convexhull(self.ptr)) + + def difference(self, other): + """ + Returns a Geometry representing the points making up this Geometry + that do not make up other. + """ + return self._topology(capi.geos_difference(self.ptr, other.ptr)) + + @property + def envelope(self): + "Return the envelope for this geometry (a polygon)." + return self._topology(capi.geos_envelope(self.ptr)) + + def interpolate(self, distance): + if not isinstance(self, (LineString, MultiLineString)): + raise TypeError('interpolate only works on LineString and MultiLineString geometries') + if not hasattr(capi, 'geos_interpolate'): + raise NotImplementedError('interpolate requires GEOS 3.2+') + return self._topology(capi.geos_interpolate(self.ptr, distance)) + + def interpolate_normalized(self, distance): + if not isinstance(self, (LineString, MultiLineString)): + raise TypeError('interpolate only works on LineString and MultiLineString geometries') + if not hasattr(capi, 'geos_interpolate_normalized'): + raise NotImplementedError('interpolate_normalized requires GEOS 3.2+') + return self._topology(capi.geos_interpolate_normalized(self.ptr, distance)) + + def intersection(self, other): + "Returns a Geometry representing the points shared by this Geometry and other." + return self._topology(capi.geos_intersection(self.ptr, other.ptr)) + + @property + def point_on_surface(self): + "Computes an interior point of this Geometry." + return self._topology(capi.geos_pointonsurface(self.ptr)) + + def project(self, point): + if not isinstance(point, Point): + raise TypeError('locate_point argument must be a Point') + if not isinstance(self, (LineString, MultiLineString)): + raise TypeError('locate_point only works on LineString and MultiLineString geometries') + if not hasattr(capi, 'geos_project'): + raise NotImplementedError('geos_project requires GEOS 3.2+') + return capi.geos_project(self.ptr, point.ptr) + + def project_normalized(self, point): + if not isinstance(point, Point): + raise TypeError('locate_point argument must be a Point') + if not isinstance(self, (LineString, MultiLineString)): + raise TypeError('locate_point only works on LineString and MultiLineString geometries') + if not hasattr(capi, 'geos_project_normalized'): + raise NotImplementedError('project_normalized requires GEOS 3.2+') + return capi.geos_project_normalized(self.ptr, point.ptr) + + def relate(self, other): + "Returns the DE-9IM intersection matrix for this Geometry and the other." + return capi.geos_relate(self.ptr, other.ptr).decode() + + def simplify(self, tolerance=0.0, preserve_topology=False): + """ + Returns the Geometry, simplified using the Douglas-Peucker algorithm + to the specified tolerance (higher tolerance => less points). If no + tolerance provided, defaults to 0. + + By default, this function does not preserve topology - e.g. polygons can + be split, collapse to lines or disappear holes can be created or + disappear, and lines can cross. By specifying preserve_topology=True, + the result will have the same dimension and number of components as the + input. This is significantly slower. + """ + if preserve_topology: + return self._topology(capi.geos_preservesimplify(self.ptr, tolerance)) + else: + return self._topology(capi.geos_simplify(self.ptr, tolerance)) + + def sym_difference(self, other): + """ + Returns a set combining the points in this Geometry not in other, + and the points in other not in this Geometry. + """ + return self._topology(capi.geos_symdifference(self.ptr, other.ptr)) + + def union(self, other): + "Returns a Geometry representing all the points in this Geometry and other." + return self._topology(capi.geos_union(self.ptr, other.ptr)) + + #### Other Routines #### + @property + def area(self): + "Returns the area of the Geometry." + return capi.geos_area(self.ptr, byref(c_double())) + + def distance(self, other): + """ + Returns the distance between the closest points on this Geometry + and the other. Units will be in those of the coordinate system of + the Geometry. + """ + if not isinstance(other, GEOSGeometry): + raise TypeError('distance() works only on other GEOS Geometries.') + return capi.geos_distance(self.ptr, other.ptr, byref(c_double())) + + @property + def extent(self): + """ + Returns the extent of this geometry as a 4-tuple, consisting of + (xmin, ymin, xmax, ymax). + """ + env = self.envelope + if isinstance(env, Point): + xmin, ymin = env.tuple + xmax, ymax = xmin, ymin + else: + xmin, ymin = env[0][0] + xmax, ymax = env[0][2] + return (xmin, ymin, xmax, ymax) + + @property + def length(self): + """ + Returns the length of this Geometry (e.g., 0 for point, or the + circumfrence of a Polygon). + """ + return capi.geos_length(self.ptr, byref(c_double())) + + def clone(self): + "Clones this Geometry." + return GEOSGeometry(capi.geom_clone(self.ptr), srid=self.srid) + +# Class mapping dictionary. Has to be at the end to avoid import +# conflicts with GEOSGeometry. +from django.contrib.gis.geos.linestring import LineString, LinearRing +from django.contrib.gis.geos.point import Point +from django.contrib.gis.geos.polygon import Polygon +from django.contrib.gis.geos.collections import GeometryCollection, MultiPoint, MultiLineString, MultiPolygon +GEOS_CLASSES = {0 : Point, + 1 : LineString, + 2 : LinearRing, + 3 : Polygon, + 4 : MultiPoint, + 5 : MultiLineString, + 6 : MultiPolygon, + 7 : GeometryCollection, + } + +# If supported, import the PreparedGeometry class. +if GEOS_PREPARE: + from django.contrib.gis.geos.prepared import PreparedGeometry diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/io.py b/lib/python2.7/site-packages/django/contrib/gis/geos/io.py new file mode 100644 index 0000000..54ba6b4 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/io.py @@ -0,0 +1,20 @@ +""" +Module that holds classes for performing I/O operations on GEOS geometry +objects. Specifically, this has Python implementations of WKB/WKT +reader and writer classes. +""" +from django.contrib.gis.geos.geometry import GEOSGeometry +from django.contrib.gis.geos.prototypes.io import _WKTReader, _WKBReader, WKBWriter, WKTWriter + +# Public classes for (WKB|WKT)Reader, which return GEOSGeometry +class WKBReader(_WKBReader): + def read(self, wkb): + "Returns a GEOSGeometry for the given WKB buffer." + return GEOSGeometry(super(WKBReader, self).read(wkb)) + +class WKTReader(_WKTReader): + def read(self, wkt): + "Returns a GEOSGeometry for the given WKT string." + return GEOSGeometry(super(WKTReader, self).read(wkt)) + + diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/libgeos.py b/lib/python2.7/site-packages/django/contrib/gis/geos/libgeos.py new file mode 100644 index 0000000..6963b78 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/libgeos.py @@ -0,0 +1,155 @@ +""" + This module houses the ctypes initialization procedures, as well + as the notice and error handler function callbacks (get called + when an error occurs in GEOS). + + This module also houses GEOS Pointer utilities, including + get_pointer_arr(), and GEOM_PTR. +""" +import logging +import os +import re +from ctypes import c_char_p, Structure, CDLL, CFUNCTYPE, POINTER +from ctypes.util import find_library + +from django.contrib.gis.geos.error import GEOSException +from django.core.exceptions import ImproperlyConfigured + +logger = logging.getLogger('django.contrib.gis') + +# Custom library path set? +try: + from django.conf import settings + lib_path = settings.GEOS_LIBRARY_PATH +except (AttributeError, EnvironmentError, + ImportError, ImproperlyConfigured): + lib_path = None + +# Setting the appropriate names for the GEOS-C library. +if lib_path: + lib_names = None +elif os.name == 'nt': + # Windows NT libraries + lib_names = ['geos_c', 'libgeos_c-1'] +elif os.name == 'posix': + # *NIX libraries + lib_names = ['geos_c', 'GEOS'] +else: + raise ImportError('Unsupported OS "%s"' % os.name) + +# Using the ctypes `find_library` utility to find the path to the GEOS +# shared library. This is better than manually specifiying each library name +# and extension (e.g., libgeos_c.[so|so.1|dylib].). +if lib_names: + for lib_name in lib_names: + lib_path = find_library(lib_name) + if not lib_path is None: break + +# No GEOS library could be found. +if lib_path is None: + raise ImportError('Could not find the GEOS library (tried "%s"). ' + 'Try setting GEOS_LIBRARY_PATH in your settings.' % + '", "'.join(lib_names)) + +# Getting the GEOS C library. The C interface (CDLL) is used for +# both *NIX and Windows. +# See the GEOS C API source code for more details on the library function calls: +# http://geos.refractions.net/ro/doxygen_docs/html/geos__c_8h-source.html +lgeos = CDLL(lib_path) + +# The notice and error handler C function callback definitions. +# Supposed to mimic the GEOS message handler (C below): +# typedef void (*GEOSMessageHandler)(const char *fmt, ...); +NOTICEFUNC = CFUNCTYPE(None, c_char_p, c_char_p) +def notice_h(fmt, lst): + fmt, lst = fmt.decode(), lst.decode() + try: + warn_msg = fmt % lst + except: + warn_msg = fmt + logger.warning('GEOS_NOTICE: %s\n' % warn_msg) +notice_h = NOTICEFUNC(notice_h) + +ERRORFUNC = CFUNCTYPE(None, c_char_p, c_char_p) +def error_h(fmt, lst): + fmt, lst = fmt.decode(), lst.decode() + try: + err_msg = fmt % lst + except: + err_msg = fmt + logger.error('GEOS_ERROR: %s\n' % err_msg) +error_h = ERRORFUNC(error_h) + +#### GEOS Geometry C data structures, and utility functions. #### + +# Opaque GEOS geometry structures, used for GEOM_PTR and CS_PTR +class GEOSGeom_t(Structure): pass +class GEOSPrepGeom_t(Structure): pass +class GEOSCoordSeq_t(Structure): pass +class GEOSContextHandle_t(Structure): pass + +# Pointers to opaque GEOS geometry structures. +GEOM_PTR = POINTER(GEOSGeom_t) +PREPGEOM_PTR = POINTER(GEOSPrepGeom_t) +CS_PTR = POINTER(GEOSCoordSeq_t) +CONTEXT_PTR = POINTER(GEOSContextHandle_t) + +# Used specifically by the GEOSGeom_createPolygon and GEOSGeom_createCollection +# GEOS routines +def get_pointer_arr(n): + "Gets a ctypes pointer array (of length `n`) for GEOSGeom_t opaque pointer." + GeomArr = GEOM_PTR * n + return GeomArr() + +# Returns the string version of the GEOS library. Have to set the restype +# explicitly to c_char_p to ensure compatibility accross 32 and 64-bit platforms. +geos_version = lgeos.GEOSversion +geos_version.argtypes = None +geos_version.restype = c_char_p + +# Regular expression should be able to parse version strings such as +# '3.0.0rc4-CAPI-1.3.3', '3.0.0-CAPI-1.4.1', '3.4.0dev-CAPI-1.8.0' or '3.4.0dev-CAPI-1.8.0 r0' +version_regex = re.compile( + r'^(?P<version>(?P<major>\d+)\.(?P<minor>\d+)\.(?P<subminor>\d+))' + r'((rc(?P<release_candidate>\d+))|dev)?-CAPI-(?P<capi_version>\d+\.\d+\.\d+)( r\d+)?$' +) +def geos_version_info(): + """ + Returns a dictionary containing the various version metadata parsed from + the GEOS version string, including the version number, whether the version + is a release candidate (and what number release candidate), and the C API + version. + """ + ver = geos_version().decode() + m = version_regex.match(ver) + if not m: + raise GEOSException('Could not parse version info string "%s"' % ver) + return dict((key, m.group(key)) for key in ( + 'version', 'release_candidate', 'capi_version', 'major', 'minor', 'subminor')) + +# Version numbers and whether or not prepared geometry support is available. +_verinfo = geos_version_info() +GEOS_MAJOR_VERSION = int(_verinfo['major']) +GEOS_MINOR_VERSION = int(_verinfo['minor']) +GEOS_SUBMINOR_VERSION = int(_verinfo['subminor']) +del _verinfo +GEOS_VERSION = (GEOS_MAJOR_VERSION, GEOS_MINOR_VERSION, GEOS_SUBMINOR_VERSION) +GEOS_PREPARE = GEOS_VERSION >= (3, 1, 0) + +if GEOS_PREPARE: + # Here we set up the prototypes for the initGEOS_r and finishGEOS_r + # routines. These functions aren't actually called until they are + # attached to a GEOS context handle -- this actually occurs in + # geos/prototypes/threadsafe.py. + lgeos.initGEOS_r.restype = CONTEXT_PTR + lgeos.finishGEOS_r.argtypes = [CONTEXT_PTR] +else: + # When thread-safety isn't available, the initGEOS routine must be called + # first. This function takes the notice and error functions, defined + # as Python callbacks above, as parameters. Here is the C code that is + # wrapped: + # extern void GEOS_DLL initGEOS(GEOSMessageHandler notice_function, GEOSMessageHandler error_function); + lgeos.initGEOS(notice_h, error_h) + # Calling finishGEOS() upon exit of the interpreter. + import atexit + atexit.register(lgeos.finishGEOS) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/linestring.py b/lib/python2.7/site-packages/django/contrib/gis/geos/linestring.py new file mode 100644 index 0000000..4784ea7 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/linestring.py @@ -0,0 +1,153 @@ +from django.contrib.gis.geos.base import numpy +from django.contrib.gis.geos.coordseq import GEOSCoordSeq +from django.contrib.gis.geos.error import GEOSException +from django.contrib.gis.geos.geometry import GEOSGeometry +from django.contrib.gis.geos.point import Point +from django.contrib.gis.geos import prototypes as capi +from django.utils.six.moves import xrange + +class LineString(GEOSGeometry): + _init_func = capi.create_linestring + _minlength = 2 + + #### 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 numpy and isinstance(coords, numpy.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(capi.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] + + # 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__(self._init_func(cs.ptr), srid=srid) + + 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 _get_single_external(self, index): + return self._cs[index] + + _get_single_internal = _get_single_external + + def _set_list(self, length, items): + ndim = self._cs.dims # + hasz = self._cs.hasz # I don't understand why these are different + + # create a new coordinate sequence and populate accordingly + cs = GEOSCoordSeq(capi.create_cs(length, ndim), z=hasz) + for i, c in enumerate(items): + cs[i] = c + + ptr = self._init_func(cs.ptr) + if ptr: + capi.destroy_geom(self.ptr) + self.ptr = ptr + self._post_init(self.srid) + else: + # can this happen? + raise GEOSException('Geometry resulting from slice deletion was invalid.') + + def _set_single(self, index, value): + self._checkindex(index) + self._cs[index] = value + + 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 numpy: return numpy.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 merged(self): + "Returns the line merge of this LineString." + return self._topology(capi.geos_linemerge(self.ptr)) + + @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): + _minLength = 4 + _init_func = capi.create_linearring diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/mutable_list.py b/lib/python2.7/site-packages/django/contrib/gis/geos/mutable_list.py new file mode 100644 index 0000000..0418282 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/mutable_list.py @@ -0,0 +1,328 @@ +# Copyright (c) 2008-2009 Aryeh Leib Taurog, all rights reserved. +# Released under the New BSD license. +""" +This module contains a base type which provides list-style mutations +without specific data storage methods. + +See also http://www.aryehleib.com/MutableLists.html + +Author: Aryeh Leib Taurog. +""" +from django.utils.functional import total_ordering +from django.utils import six +from django.utils.six.moves import xrange + +@total_ordering +class ListMixin(object): + """ + A base class which provides complete list interface. + Derived classes must call ListMixin's __init__() function + and implement the following: + + function _get_single_external(self, i): + Return single item with index i for general use. + The index i will always satisfy 0 <= i < len(self). + + function _get_single_internal(self, i): + Same as above, but for use within the class [Optional] + Note that if _get_single_internal and _get_single_internal return + different types of objects, _set_list must distinguish + between the two and handle each appropriately. + + function _set_list(self, length, items): + Recreate the entire object. + + NOTE: items may be a generator which calls _get_single_internal. + Therefore, it is necessary to cache the values in a temporary: + temp = list(items) + before clobbering the original storage. + + function _set_single(self, i, value): + Set the single item at index i to value [Optional] + If left undefined, all mutations will result in rebuilding + the object using _set_list. + + function __len__(self): + Return the length + + int _minlength: + The minimum legal length [Optional] + + int _maxlength: + The maximum legal length [Optional] + + type or tuple _allowed: + A type or tuple of allowed item types [Optional] + + class _IndexError: + The type of exception to be raise on invalid index [Optional] + """ + + _minlength = 0 + _maxlength = None + _IndexError = IndexError + + ### Python initialization and special list interface methods ### + + def __init__(self, *args, **kwargs): + if not hasattr(self, '_get_single_internal'): + self._get_single_internal = self._get_single_external + + if not hasattr(self, '_set_single'): + self._set_single = self._set_single_rebuild + self._assign_extended_slice = self._assign_extended_slice_rebuild + + super(ListMixin, self).__init__(*args, **kwargs) + + def __getitem__(self, index): + "Get the item(s) at the specified index/slice." + if isinstance(index, slice): + return [self._get_single_external(i) for i in xrange(*index.indices(len(self)))] + else: + index = self._checkindex(index) + return self._get_single_external(index) + + def __delitem__(self, index): + "Delete the item(s) at the specified index/slice." + if not isinstance(index, six.integer_types + (slice,)): + raise TypeError("%s is not a legal index" % index) + + # calculate new length and dimensions + origLen = len(self) + if isinstance(index, six.integer_types): + index = self._checkindex(index) + indexRange = [index] + else: + indexRange = range(*index.indices(origLen)) + + newLen = origLen - len(indexRange) + newItems = ( self._get_single_internal(i) + for i in xrange(origLen) + if i not in indexRange ) + + self._rebuild(newLen, newItems) + + def __setitem__(self, index, val): + "Set the item(s) at the specified index/slice." + if isinstance(index, slice): + self._set_slice(index, val) + else: + index = self._checkindex(index) + self._check_allowed((val,)) + self._set_single(index, val) + + def __iter__(self): + "Iterate over the items in the list" + for i in xrange(len(self)): + yield self[i] + + ### Special methods for arithmetic operations ### + def __add__(self, other): + 'add another list-like object' + return self.__class__(list(self) + list(other)) + + def __radd__(self, other): + 'add to another list-like object' + return other.__class__(list(other) + list(self)) + + def __iadd__(self, other): + 'add another list-like object to self' + self.extend(list(other)) + return self + + def __mul__(self, n): + 'multiply' + return self.__class__(list(self) * n) + + def __rmul__(self, n): + 'multiply' + return self.__class__(list(self) * n) + + def __imul__(self, n): + 'multiply' + if n <= 0: + del self[:] + else: + cache = list(self) + for i in range(n-1): + self.extend(cache) + return self + + def __eq__(self, other): + olen = len(other) + for i in range(olen): + try: + c = self[i] == other[i] + except self._IndexError: + # self must be shorter + return False + if not c: + return False + return len(self) == olen + + def __lt__(self, other): + olen = len(other) + for i in range(olen): + try: + c = self[i] < other[i] + except self._IndexError: + # self must be shorter + return True + if c: + return c + elif other[i] < self[i]: + return False + return len(self) < olen + + ### Public list interface Methods ### + ## Non-mutating ## + def count(self, val): + "Standard list count method" + count = 0 + for i in self: + if val == i: count += 1 + return count + + def index(self, val): + "Standard list index method" + for i in xrange(0, len(self)): + if self[i] == val: return i + raise ValueError('%s not found in object' % str(val)) + + ## Mutating ## + def append(self, val): + "Standard list append method" + self[len(self):] = [val] + + def extend(self, vals): + "Standard list extend method" + self[len(self):] = vals + + def insert(self, index, val): + "Standard list insert method" + if not isinstance(index, six.integer_types): + raise TypeError("%s is not a legal index" % index) + self[index:index] = [val] + + def pop(self, index=-1): + "Standard list pop method" + result = self[index] + del self[index] + return result + + def remove(self, val): + "Standard list remove method" + del self[self.index(val)] + + def reverse(self): + "Standard list reverse method" + self[:] = self[-1::-1] + + def sort(self, cmp=None, key=None, reverse=False): + "Standard list sort method" + if key: + temp = [(key(v),v) for v in self] + temp.sort(key=lambda x: x[0], reverse=reverse) + self[:] = [v[1] for v in temp] + else: + temp = list(self) + if cmp is not None: + temp.sort(cmp=cmp, reverse=reverse) + else: + temp.sort(reverse=reverse) + self[:] = temp + + ### Private routines ### + def _rebuild(self, newLen, newItems): + if newLen < self._minlength: + raise ValueError('Must have at least %d items' % self._minlength) + if self._maxlength is not None and newLen > self._maxlength: + raise ValueError('Cannot have more than %d items' % self._maxlength) + + self._set_list(newLen, newItems) + + def _set_single_rebuild(self, index, value): + self._set_slice(slice(index, index + 1, 1), [value]) + + def _checkindex(self, index, correct=True): + length = len(self) + if 0 <= index < length: + return index + if correct and -length <= index < 0: + return index + length + raise self._IndexError('invalid index: %s' % str(index)) + + def _check_allowed(self, items): + if hasattr(self, '_allowed'): + if False in [isinstance(val, self._allowed) for val in items]: + raise TypeError('Invalid type encountered in the arguments.') + + def _set_slice(self, index, values): + "Assign values to a slice of the object" + try: + iter(values) + except TypeError: + raise TypeError('can only assign an iterable to a slice') + + self._check_allowed(values) + + origLen = len(self) + valueList = list(values) + start, stop, step = index.indices(origLen) + + # CAREFUL: index.step and step are not the same! + # step will never be None + if index.step is None: + self._assign_simple_slice(start, stop, valueList) + else: + self._assign_extended_slice(start, stop, step, valueList) + + def _assign_extended_slice_rebuild(self, start, stop, step, valueList): + 'Assign an extended slice by rebuilding entire list' + indexList = range(start, stop, step) + # extended slice, only allow assigning slice of same size + if len(valueList) != len(indexList): + raise ValueError('attempt to assign sequence of size %d ' + 'to extended slice of size %d' + % (len(valueList), len(indexList))) + + # we're not changing the length of the sequence + newLen = len(self) + newVals = dict(zip(indexList, valueList)) + def newItems(): + for i in xrange(newLen): + if i in newVals: + yield newVals[i] + else: + yield self._get_single_internal(i) + + self._rebuild(newLen, newItems()) + + def _assign_extended_slice(self, start, stop, step, valueList): + 'Assign an extended slice by re-assigning individual items' + indexList = range(start, stop, step) + # extended slice, only allow assigning slice of same size + if len(valueList) != len(indexList): + raise ValueError('attempt to assign sequence of size %d ' + 'to extended slice of size %d' + % (len(valueList), len(indexList))) + + for i, val in zip(indexList, valueList): + self._set_single(i, val) + + def _assign_simple_slice(self, start, stop, valueList): + 'Assign a simple slice; Can assign slice of any length' + origLen = len(self) + stop = max(start, stop) + newLen = origLen - stop + start + len(valueList) + def newItems(): + for i in xrange(origLen + 1): + if i == start: + for val in valueList: + yield val + + if i < origLen: + if i < start or i >= stop: + yield self._get_single_internal(i) + + self._rebuild(newLen, newItems()) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/point.py b/lib/python2.7/site-packages/django/contrib/gis/geos/point.py new file mode 100644 index 0000000..907347d --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/point.py @@ -0,0 +1,137 @@ +from ctypes import c_uint +from django.contrib.gis.geos.error import GEOSException +from django.contrib.gis.geos.geometry import GEOSGeometry +from django.contrib.gis.geos import prototypes as capi +from django.utils import six +from django.utils.six.moves import xrange + +class Point(GEOSGeometry): + _minlength = 2 + _maxlength = 3 + + 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) + coords = x + elif isinstance(x, six.integer_types + (float,)) and isinstance(y, six.integer_types + (float,)): + # Here X, Y, and (optionally) Z were passed in individually, as parameters. + if isinstance(z, six.integer_types + (float,)): + ndim = 3 + coords = [x, y, z] + else: + ndim = 2 + coords = [x, y] + else: + raise TypeError('Invalid parameters given for Point initialization.') + + point = self._create_point(ndim, coords) + + # Initializing using the address returned from the GEOS + # createPoint factory. + super(Point, self).__init__(point, srid=srid) + + def _create_point(self, ndim, coords): + """ + Create a coordinate sequence, set X, Y, [Z], and create point + """ + if ndim < 2 or ndim > 3: + raise TypeError('Invalid point dimension: %s' % str(ndim)) + + cs = capi.create_cs(c_uint(1), c_uint(ndim)) + i = iter(coords) + capi.cs_setx(cs, 0, next(i)) + capi.cs_sety(cs, 0, next(i)) + if ndim == 3: capi.cs_setz(cs, 0, next(i)) + + return capi.create_point(cs) + + def _set_list(self, length, items): + ptr = self._create_point(length, items) + if ptr: + capi.destroy_geom(self.ptr) + self._ptr = ptr + self._set_cs() + else: + # can this happen? + raise GEOSException('Geometry resulting from slice deletion was invalid.') + + def _set_single(self, index, value): + self._cs.setOrdinate(index, 0, value) + + def __iter__(self): + "Allows iteration over coordinates of this Point." + for i in xrange(len(self)): + yield self[i] + + 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_single_external(self, index): + if index == 0: + return self.x + elif index == 1: + return self.y + elif index == 2: + return self.z + + _get_single_internal = _get_single_external + + 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 diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/polygon.py b/lib/python2.7/site-packages/django/contrib/gis/geos/polygon.py new file mode 100644 index 0000000..c50f549 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/polygon.py @@ -0,0 +1,170 @@ +from ctypes import c_uint, byref +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 +from django.utils import six +from django.utils.six.moves import xrange + +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 + for z in bbox: + if not isinstance(z, six.integer_types + (float,)): + return GEOSGeometry('POLYGON((%s %s, %s %s, %s %s, %s %s, %s %s))' % + (x0, y0, x0, y1, x1, y1, x1, y0, x0, y0)) + return Polygon(((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) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prepared.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prepared.py new file mode 100644 index 0000000..ae2548f --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prepared.py @@ -0,0 +1,35 @@ +from django.contrib.gis.geos.base import GEOSBase +from django.contrib.gis.geos.geometry import GEOSGeometry +from django.contrib.gis.geos.prototypes import prepared as capi + +class PreparedGeometry(GEOSBase): + """ + A geometry that is prepared for performing certain operations. + At the moment this includes the contains covers, and intersects + operations. + """ + ptr_type = capi.PREPGEOM_PTR + + def __init__(self, geom): + # Keeping a reference to the original geometry object to prevent it + # from being garbage collected which could then crash the prepared one + # See #21662 + self._base_geom = geom + if not isinstance(geom, GEOSGeometry): + raise TypeError + self.ptr = capi.geos_prepare(geom.ptr) + + def __del__(self): + if self._ptr: capi.prepared_destroy(self._ptr) + + def contains(self, other): + return capi.prepared_contains(self.ptr, other.ptr) + + def contains_properly(self, other): + return capi.prepared_contains_properly(self.ptr, other.ptr) + + def covers(self, other): + return capi.prepared_covers(self.ptr, other.ptr) + + def intersects(self, other): + return capi.prepared_intersects(self.ptr, other.ptr) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/__init__.py new file mode 100644 index 0000000..89b96c0 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/__init__.py @@ -0,0 +1,30 @@ +""" + This module contains all of the GEOS ctypes function prototypes. Each + prototype handles the interaction between the GEOS library and Python + via ctypes. +""" + +# Coordinate sequence routines. +from django.contrib.gis.geos.prototypes.coordseq import (create_cs, get_cs, + cs_clone, cs_getordinate, cs_setordinate, cs_getx, cs_gety, cs_getz, + cs_setx, cs_sety, cs_setz, cs_getsize, cs_getdims) + +# Geometry routines. +from django.contrib.gis.geos.prototypes.geom import (from_hex, from_wkb, from_wkt, + create_point, create_linestring, create_linearring, create_polygon, create_collection, + destroy_geom, get_extring, get_intring, get_nrings, get_geomn, geom_clone, + geos_normalize, geos_type, geos_typeid, geos_get_srid, geos_set_srid, + get_dims, get_num_coords, get_num_geoms, + to_hex, to_wkb, to_wkt) + +# Miscellaneous routines. +from django.contrib.gis.geos.prototypes.misc import * + +# Predicates +from django.contrib.gis.geos.prototypes.predicates import (geos_hasz, geos_isempty, + geos_isring, geos_issimple, geos_isvalid, geos_contains, geos_crosses, + geos_disjoint, geos_equals, geos_equalsexact, geos_intersects, + geos_intersects, geos_overlaps, geos_relatepattern, geos_touches, geos_within) + +# Topology routines +from django.contrib.gis.geos.prototypes.topology import * diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/coordseq.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/coordseq.py new file mode 100644 index 0000000..68b9480 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/coordseq.py @@ -0,0 +1,83 @@ +from ctypes import c_double, c_int, c_uint, POINTER +from django.contrib.gis.geos.libgeos import GEOM_PTR, CS_PTR +from django.contrib.gis.geos.prototypes.errcheck import last_arg_byref, GEOSException +from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc + +## Error-checking routines specific to coordinate sequences. ## +def check_cs_ptr(result, func, cargs): + "Error checking on routines that return Geometries." + if not result: + raise GEOSException('Error encountered checking Coordinate Sequence returned from GEOS C function "%s".' % func.__name__) + return result + +def check_cs_op(result, func, cargs): + "Checks the status code of a coordinate sequence operation." + if result == 0: + raise GEOSException('Could not set value on coordinate sequence') + else: + return result + +def check_cs_get(result, func, cargs): + "Checking the coordinate sequence retrieval." + check_cs_op(result, func, cargs) + # Object in by reference, return its value. + return last_arg_byref(cargs) + +## Coordinate sequence prototype generation functions. ## +def cs_int(func): + "For coordinate sequence routines that return an integer." + func.argtypes = [CS_PTR, POINTER(c_uint)] + func.restype = c_int + func.errcheck = check_cs_get + return func + +def cs_operation(func, ordinate=False, get=False): + "For coordinate sequence operations." + if get: + # Get routines get double parameter passed-in by reference. + func.errcheck = check_cs_get + dbl_param = POINTER(c_double) + else: + func.errcheck = check_cs_op + dbl_param = c_double + + if ordinate: + # Get/Set ordinate routines have an extra uint parameter. + func.argtypes = [CS_PTR, c_uint, c_uint, dbl_param] + else: + func.argtypes = [CS_PTR, c_uint, dbl_param] + + func.restype = c_int + return func + +def cs_output(func, argtypes): + "For routines that return a coordinate sequence." + func.argtypes = argtypes + func.restype = CS_PTR + func.errcheck = check_cs_ptr + return func + +## Coordinate Sequence ctypes prototypes ## + +# Coordinate Sequence constructors & cloning. +cs_clone = cs_output(GEOSFunc('GEOSCoordSeq_clone'), [CS_PTR]) +create_cs = cs_output(GEOSFunc('GEOSCoordSeq_create'), [c_uint, c_uint]) +get_cs = cs_output(GEOSFunc('GEOSGeom_getCoordSeq'), [GEOM_PTR]) + +# Getting, setting ordinate +cs_getordinate = cs_operation(GEOSFunc('GEOSCoordSeq_getOrdinate'), ordinate=True, get=True) +cs_setordinate = cs_operation(GEOSFunc('GEOSCoordSeq_setOrdinate'), ordinate=True) + +# For getting, x, y, z +cs_getx = cs_operation(GEOSFunc('GEOSCoordSeq_getX'), get=True) +cs_gety = cs_operation(GEOSFunc('GEOSCoordSeq_getY'), get=True) +cs_getz = cs_operation(GEOSFunc('GEOSCoordSeq_getZ'), get=True) + +# For setting, x, y, z +cs_setx = cs_operation(GEOSFunc('GEOSCoordSeq_setX')) +cs_sety = cs_operation(GEOSFunc('GEOSCoordSeq_setY')) +cs_setz = cs_operation(GEOSFunc('GEOSCoordSeq_setZ')) + +# These routines return size & dimensions. +cs_getsize = cs_int(GEOSFunc('GEOSCoordSeq_getSize')) +cs_getdims = cs_int(GEOSFunc('GEOSCoordSeq_getDimensions')) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/errcheck.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/errcheck.py new file mode 100644 index 0000000..97fcd21 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/errcheck.py @@ -0,0 +1,95 @@ +""" + Error checking functions for GEOS ctypes prototype functions. +""" +import os +from ctypes import c_void_p, string_at, CDLL +from django.contrib.gis.geos.error import GEOSException +from django.contrib.gis.geos.libgeos import GEOS_VERSION +from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc + +# Getting the `free` routine used to free the memory allocated for +# string pointers returned by GEOS. +if GEOS_VERSION >= (3, 1, 1): + # In versions 3.1.1 and above, `GEOSFree` was added to the C API + # because `free` isn't always available on all platforms. + free = GEOSFunc('GEOSFree') + free.argtypes = [c_void_p] + free.restype = None +else: + # Getting the `free` routine from the C library of the platform. + if os.name == 'nt': + # On NT, use the MS C library. + libc = CDLL('msvcrt') + else: + # On POSIX platforms C library is obtained by passing None into `CDLL`. + libc = CDLL(None) + free = libc.free + +### ctypes error checking routines ### +def last_arg_byref(args): + "Returns the last C argument's value by reference." + return args[-1]._obj.value + +def check_dbl(result, func, cargs): + "Checks the status code and returns the double value passed in by reference." + # Checking the status code + if result != 1: return None + # Double passed in by reference, return its value. + return last_arg_byref(cargs) + +def check_geom(result, func, cargs): + "Error checking on routines that return Geometries." + if not result: + raise GEOSException('Error encountered checking Geometry returned from GEOS C function "%s".' % func.__name__) + return result + +def check_minus_one(result, func, cargs): + "Error checking on routines that should not return -1." + if result == -1: + raise GEOSException('Error encountered in GEOS C function "%s".' % func.__name__) + else: + return result + +def check_predicate(result, func, cargs): + "Error checking for unary/binary predicate functions." + val = ord(result) # getting the ordinal from the character + if val == 1: return True + elif val == 0: return False + else: + raise GEOSException('Error encountered on GEOS C predicate function "%s".' % func.__name__) + +def check_sized_string(result, func, cargs): + """ + Error checking for routines that return explicitly sized strings. + + This frees the memory allocated by GEOS at the result pointer. + """ + if not result: + raise GEOSException('Invalid string pointer returned by GEOS C function "%s"' % func.__name__) + # A c_size_t object is passed in by reference for the second + # argument on these routines, and its needed to determine the + # correct size. + s = string_at(result, last_arg_byref(cargs)) + # Freeing the memory allocated within GEOS + free(result) + return s + +def check_string(result, func, cargs): + """ + Error checking for routines that return strings. + + This frees the memory allocated by GEOS at the result pointer. + """ + if not result: raise GEOSException('Error encountered checking string return value in GEOS C function "%s".' % func.__name__) + # Getting the string value at the pointer address. + s = string_at(result) + # Freeing the memory allocated within GEOS + free(result) + return s + +def check_zero(result, func, cargs): + "Error checking on routines that should not return 0." + if result == 0: + raise GEOSException('Error encountered in GEOS C function "%s".' % func.__name__) + else: + return result diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/geom.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/geom.py new file mode 100644 index 0000000..2683c2e --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/geom.py @@ -0,0 +1,119 @@ +from ctypes import c_char_p, c_int, c_size_t, c_ubyte, POINTER +from django.contrib.gis.geos.libgeos import CS_PTR, GEOM_PTR +from django.contrib.gis.geos.prototypes.errcheck import ( + check_geom, check_minus_one, check_sized_string, check_string, check_zero) +from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc + +# This is the return type used by binary output (WKB, HEX) routines. +c_uchar_p = POINTER(c_ubyte) + +# We create a simple subclass of c_char_p here because when the response +# type is set to c_char_p, you get a _Python_ string and there's no way +# to access the string's address inside the error checking function. +# In other words, you can't free the memory allocated inside GEOS. Previously, +# the return type would just be omitted and the integer address would be +# used -- but this allows us to be specific in the function definition and +# keeps the reference so it may be free'd. +class geos_char_p(c_char_p): + pass + +### ctypes generation functions ### +def bin_constructor(func): + "Generates a prototype for binary construction (HEX, WKB) GEOS routines." + func.argtypes = [c_char_p, c_size_t] + func.restype = GEOM_PTR + func.errcheck = check_geom + return func + +# HEX & WKB output +def bin_output(func): + "Generates a prototype for the routines that return a sized string." + func.argtypes = [GEOM_PTR, POINTER(c_size_t)] + func.errcheck = check_sized_string + func.restype = c_uchar_p + return func + +def geom_output(func, argtypes): + "For GEOS routines that return a geometry." + if argtypes: func.argtypes = argtypes + func.restype = GEOM_PTR + func.errcheck = check_geom + return func + +def geom_index(func): + "For GEOS routines that return geometries from an index." + return geom_output(func, [GEOM_PTR, c_int]) + +def int_from_geom(func, zero=False): + "Argument is a geometry, return type is an integer." + func.argtypes = [GEOM_PTR] + func.restype = c_int + if zero: + func.errcheck = check_zero + else: + func.errcheck = check_minus_one + return func + +def string_from_geom(func): + "Argument is a Geometry, return type is a string." + func.argtypes = [GEOM_PTR] + func.restype = geos_char_p + func.errcheck = check_string + return func + +### ctypes prototypes ### + +# Deprecated creation routines from WKB, HEX, WKT +from_hex = bin_constructor(GEOSFunc('GEOSGeomFromHEX_buf')) +from_wkb = bin_constructor(GEOSFunc('GEOSGeomFromWKB_buf')) +from_wkt = geom_output(GEOSFunc('GEOSGeomFromWKT'), [c_char_p]) + +# Deprecated output routines +to_hex = bin_output(GEOSFunc('GEOSGeomToHEX_buf')) +to_wkb = bin_output(GEOSFunc('GEOSGeomToWKB_buf')) +to_wkt = string_from_geom(GEOSFunc('GEOSGeomToWKT')) + +# The GEOS geometry type, typeid, num_coordites and number of geometries +geos_normalize = int_from_geom(GEOSFunc('GEOSNormalize')) +geos_type = string_from_geom(GEOSFunc('GEOSGeomType')) +geos_typeid = int_from_geom(GEOSFunc('GEOSGeomTypeId')) +get_dims = int_from_geom(GEOSFunc('GEOSGeom_getDimensions'), zero=True) +get_num_coords = int_from_geom(GEOSFunc('GEOSGetNumCoordinates')) +get_num_geoms = int_from_geom(GEOSFunc('GEOSGetNumGeometries')) + +# Geometry creation factories +create_point = geom_output(GEOSFunc('GEOSGeom_createPoint'), [CS_PTR]) +create_linestring = geom_output(GEOSFunc('GEOSGeom_createLineString'), [CS_PTR]) +create_linearring = geom_output(GEOSFunc('GEOSGeom_createLinearRing'), [CS_PTR]) + +# Polygon and collection creation routines are special and will not +# have their argument types defined. +create_polygon = geom_output(GEOSFunc('GEOSGeom_createPolygon'), None) +create_collection = geom_output(GEOSFunc('GEOSGeom_createCollection'), None) + +# Ring routines +get_extring = geom_output(GEOSFunc('GEOSGetExteriorRing'), [GEOM_PTR]) +get_intring = geom_index(GEOSFunc('GEOSGetInteriorRingN')) +get_nrings = int_from_geom(GEOSFunc('GEOSGetNumInteriorRings')) + +# Collection Routines +get_geomn = geom_index(GEOSFunc('GEOSGetGeometryN')) + +# Cloning +geom_clone = GEOSFunc('GEOSGeom_clone') +geom_clone.argtypes = [GEOM_PTR] +geom_clone.restype = GEOM_PTR + +# Destruction routine. +destroy_geom = GEOSFunc('GEOSGeom_destroy') +destroy_geom.argtypes = [GEOM_PTR] +destroy_geom.restype = None + +# SRID routines +geos_get_srid = GEOSFunc('GEOSGetSRID') +geos_get_srid.argtypes = [GEOM_PTR] +geos_get_srid.restype = c_int + +geos_set_srid = GEOSFunc('GEOSSetSRID') +geos_set_srid.argtypes = [GEOM_PTR, c_int] +geos_set_srid.restype = None diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/io.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/io.py new file mode 100644 index 0000000..1e80351 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/io.py @@ -0,0 +1,265 @@ +import threading +from ctypes import byref, c_char_p, c_int, c_char, c_size_t, Structure, POINTER +from django.contrib.gis import memoryview +from django.contrib.gis.geos.base import GEOSBase +from django.contrib.gis.geos.libgeos import GEOM_PTR +from django.contrib.gis.geos.prototypes.errcheck import check_geom, check_string, check_sized_string +from django.contrib.gis.geos.prototypes.geom import c_uchar_p, geos_char_p +from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc + +from django.utils import six +from django.utils.encoding import force_bytes + +### The WKB/WKT Reader/Writer structures and pointers ### +class WKTReader_st(Structure): pass +class WKTWriter_st(Structure): pass +class WKBReader_st(Structure): pass +class WKBWriter_st(Structure): pass + +WKT_READ_PTR = POINTER(WKTReader_st) +WKT_WRITE_PTR = POINTER(WKTWriter_st) +WKB_READ_PTR = POINTER(WKBReader_st) +WKB_WRITE_PTR = POINTER(WKBReader_st) + +### WKTReader routines ### +wkt_reader_create = GEOSFunc('GEOSWKTReader_create') +wkt_reader_create.restype = WKT_READ_PTR + +wkt_reader_destroy = GEOSFunc('GEOSWKTReader_destroy') +wkt_reader_destroy.argtypes = [WKT_READ_PTR] + +wkt_reader_read = GEOSFunc('GEOSWKTReader_read') +wkt_reader_read.argtypes = [WKT_READ_PTR, c_char_p] +wkt_reader_read.restype = GEOM_PTR +wkt_reader_read.errcheck = check_geom + +### WKTWriter routines ### +wkt_writer_create = GEOSFunc('GEOSWKTWriter_create') +wkt_writer_create.restype = WKT_WRITE_PTR + +wkt_writer_destroy = GEOSFunc('GEOSWKTWriter_destroy') +wkt_writer_destroy.argtypes = [WKT_WRITE_PTR] + +wkt_writer_write = GEOSFunc('GEOSWKTWriter_write') +wkt_writer_write.argtypes = [WKT_WRITE_PTR, GEOM_PTR] +wkt_writer_write.restype = geos_char_p +wkt_writer_write.errcheck = check_string + +try: + wkt_writer_get_outdim = GEOSFunc('GEOSWKTWriter_getOutputDimension') + wkt_writer_get_outdim.argtypes = [WKT_WRITE_PTR] + wkt_writer_get_outdim.restype = c_int + wkt_writer_set_outdim = GEOSFunc('GEOSWKTWriter_setOutputDimension') + wkt_writer_set_outdim.argtypes = [WKT_WRITE_PTR, c_int] +except AttributeError: + # GEOSWKTWriter_get/setOutputDimension has been introduced in GEOS 3.3.0 + # Always return 2 if not available + wkt_writer_get_outdim = lambda ptr: 2 + wkt_writer_set_outdim = lambda ptr, dim: None + +### WKBReader routines ### +wkb_reader_create = GEOSFunc('GEOSWKBReader_create') +wkb_reader_create.restype = WKB_READ_PTR + +wkb_reader_destroy = GEOSFunc('GEOSWKBReader_destroy') +wkb_reader_destroy.argtypes = [WKB_READ_PTR] + +def wkb_read_func(func): + # Although the function definitions take `const unsigned char *` + # as their parameter, we use c_char_p here so the function may + # take Python strings directly as parameters. Inside Python there + # is not a difference between signed and unsigned characters, so + # it is not a problem. + func.argtypes = [WKB_READ_PTR, c_char_p, c_size_t] + func.restype = GEOM_PTR + func.errcheck = check_geom + return func + +wkb_reader_read = wkb_read_func(GEOSFunc('GEOSWKBReader_read')) +wkb_reader_read_hex = wkb_read_func(GEOSFunc('GEOSWKBReader_readHEX')) + +### WKBWriter routines ### +wkb_writer_create = GEOSFunc('GEOSWKBWriter_create') +wkb_writer_create.restype = WKB_WRITE_PTR + +wkb_writer_destroy = GEOSFunc('GEOSWKBWriter_destroy') +wkb_writer_destroy.argtypes = [WKB_WRITE_PTR] + +# WKB Writing prototypes. +def wkb_write_func(func): + func.argtypes = [WKB_WRITE_PTR, GEOM_PTR, POINTER(c_size_t)] + func.restype = c_uchar_p + func.errcheck = check_sized_string + return func + +wkb_writer_write = wkb_write_func(GEOSFunc('GEOSWKBWriter_write')) +wkb_writer_write_hex = wkb_write_func(GEOSFunc('GEOSWKBWriter_writeHEX')) + +# WKBWriter property getter/setter prototypes. +def wkb_writer_get(func, restype=c_int): + func.argtypes = [WKB_WRITE_PTR] + func.restype = restype + return func + +def wkb_writer_set(func, argtype=c_int): + func.argtypes = [WKB_WRITE_PTR, argtype] + return func + +wkb_writer_get_byteorder = wkb_writer_get(GEOSFunc('GEOSWKBWriter_getByteOrder')) +wkb_writer_set_byteorder = wkb_writer_set(GEOSFunc('GEOSWKBWriter_setByteOrder')) +wkb_writer_get_outdim = wkb_writer_get(GEOSFunc('GEOSWKBWriter_getOutputDimension')) +wkb_writer_set_outdim = wkb_writer_set(GEOSFunc('GEOSWKBWriter_setOutputDimension')) +wkb_writer_get_include_srid = wkb_writer_get(GEOSFunc('GEOSWKBWriter_getIncludeSRID'), restype=c_char) +wkb_writer_set_include_srid = wkb_writer_set(GEOSFunc('GEOSWKBWriter_setIncludeSRID'), argtype=c_char) + +### Base I/O Class ### +class IOBase(GEOSBase): + "Base class for GEOS I/O objects." + def __init__(self): + # Getting the pointer with the constructor. + self.ptr = self._constructor() + + def __del__(self): + # Cleaning up with the appropriate destructor. + if self._ptr: self._destructor(self._ptr) + +### Base WKB/WKT Reading and Writing objects ### + +# Non-public WKB/WKT reader classes for internal use because +# their `read` methods return _pointers_ instead of GEOSGeometry +# objects. +class _WKTReader(IOBase): + _constructor = wkt_reader_create + _destructor = wkt_reader_destroy + ptr_type = WKT_READ_PTR + + def read(self, wkt): + if not isinstance(wkt, (bytes, six.string_types)): + raise TypeError + return wkt_reader_read(self.ptr, force_bytes(wkt)) + +class _WKBReader(IOBase): + _constructor = wkb_reader_create + _destructor = wkb_reader_destroy + ptr_type = WKB_READ_PTR + + def read(self, wkb): + "Returns a _pointer_ to C GEOS Geometry object from the given WKB." + if isinstance(wkb, memoryview): + wkb_s = bytes(wkb) + return wkb_reader_read(self.ptr, wkb_s, len(wkb_s)) + elif isinstance(wkb, (bytes, six.string_types)): + return wkb_reader_read_hex(self.ptr, wkb, len(wkb)) + else: + raise TypeError + +### WKB/WKT Writer Classes ### +class WKTWriter(IOBase): + _constructor = wkt_writer_create + _destructor = wkt_writer_destroy + ptr_type = WKT_WRITE_PTR + + def write(self, geom): + "Returns the WKT representation of the given geometry." + return wkt_writer_write(self.ptr, geom.ptr) + + @property + def outdim(self): + return wkt_writer_get_outdim(self.ptr) + + @outdim.setter + def outdim(self, new_dim): + if not new_dim in (2, 3): + raise ValueError('WKT output dimension must be 2 or 3') + wkt_writer_set_outdim(self.ptr, new_dim) + + +class WKBWriter(IOBase): + _constructor = wkb_writer_create + _destructor = wkb_writer_destroy + ptr_type = WKB_WRITE_PTR + + def write(self, geom): + "Returns the WKB representation of the given geometry." + return memoryview(wkb_writer_write(self.ptr, geom.ptr, byref(c_size_t()))) + + def write_hex(self, geom): + "Returns the HEXEWKB representation of the given geometry." + return wkb_writer_write_hex(self.ptr, geom.ptr, byref(c_size_t())) + + ### WKBWriter Properties ### + + # Property for getting/setting the byteorder. + def _get_byteorder(self): + return wkb_writer_get_byteorder(self.ptr) + + def _set_byteorder(self, order): + if not order in (0, 1): raise ValueError('Byte order parameter must be 0 (Big Endian) or 1 (Little Endian).') + wkb_writer_set_byteorder(self.ptr, order) + + byteorder = property(_get_byteorder, _set_byteorder) + + # Property for getting/setting the output dimension. + def _get_outdim(self): + return wkb_writer_get_outdim(self.ptr) + + def _set_outdim(self, new_dim): + if not new_dim in (2, 3): raise ValueError('WKB output dimension must be 2 or 3') + wkb_writer_set_outdim(self.ptr, new_dim) + + outdim = property(_get_outdim, _set_outdim) + + # Property for getting/setting the include srid flag. + def _get_include_srid(self): + return bool(ord(wkb_writer_get_include_srid(self.ptr))) + + def _set_include_srid(self, include): + if bool(include): flag = b'\x01' + else: flag = b'\x00' + wkb_writer_set_include_srid(self.ptr, flag) + + srid = property(_get_include_srid, _set_include_srid) + +# `ThreadLocalIO` object holds instances of the WKT and WKB reader/writer +# objects that are local to the thread. The `GEOSGeometry` internals +# access these instances by calling the module-level functions, defined +# below. +class ThreadLocalIO(threading.local): + wkt_r = None + wkt_w = None + wkb_r = None + wkb_w = None + ewkb_w = None + +thread_context = ThreadLocalIO() + +# These module-level routines return the I/O object that is local to the +# thread. If the I/O object does not exist yet it will be initialized. +def wkt_r(): + if not thread_context.wkt_r: + thread_context.wkt_r = _WKTReader() + return thread_context.wkt_r + +def wkt_w(dim=2): + if not thread_context.wkt_w: + thread_context.wkt_w = WKTWriter() + thread_context.wkt_w.outdim = dim + return thread_context.wkt_w + +def wkb_r(): + if not thread_context.wkb_r: + thread_context.wkb_r = _WKBReader() + return thread_context.wkb_r + +def wkb_w(dim=2): + if not thread_context.wkb_w: + thread_context.wkb_w = WKBWriter() + thread_context.wkb_w.outdim = dim + return thread_context.wkb_w + +def ewkb_w(dim=2): + if not thread_context.ewkb_w: + thread_context.ewkb_w = WKBWriter() + thread_context.ewkb_w.srid = True + thread_context.ewkb_w.outdim = dim + return thread_context.ewkb_w diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/misc.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/misc.py new file mode 100644 index 0000000..5a9b555 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/misc.py @@ -0,0 +1,40 @@ +""" + This module is for the miscellaneous GEOS routines, particularly the + ones that return the area, distance, and length. +""" +from ctypes import c_int, c_double, POINTER +from django.contrib.gis.geos.libgeos import GEOM_PTR, GEOS_PREPARE +from django.contrib.gis.geos.prototypes.errcheck import check_dbl, check_string +from django.contrib.gis.geos.prototypes.geom import geos_char_p +from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc +from django.utils.six.moves import xrange + +__all__ = ['geos_area', 'geos_distance', 'geos_length'] + +### ctypes generator function ### +def dbl_from_geom(func, num_geom=1): + """ + Argument is a Geometry, return type is double that is passed + in by reference as the last argument. + """ + argtypes = [GEOM_PTR for i in xrange(num_geom)] + argtypes += [POINTER(c_double)] + func.argtypes = argtypes + func.restype = c_int # Status code returned + func.errcheck = check_dbl + return func + +### ctypes prototypes ### + +# Area, distance, and length prototypes. +geos_area = dbl_from_geom(GEOSFunc('GEOSArea')) +geos_distance = dbl_from_geom(GEOSFunc('GEOSDistance'), num_geom=2) +geos_length = dbl_from_geom(GEOSFunc('GEOSLength')) + +# Validity reason; only in GEOS 3.1+ +if GEOS_PREPARE: + geos_isvalidreason = GEOSFunc('GEOSisValidReason') + geos_isvalidreason.argtypes = [GEOM_PTR] + geos_isvalidreason.restype = geos_char_p + geos_isvalidreason.errcheck = check_string + __all__.append('geos_isvalidreason') diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/predicates.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/predicates.py new file mode 100644 index 0000000..bf69bb1 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/predicates.py @@ -0,0 +1,44 @@ +""" + This module houses the GEOS ctypes prototype functions for the + unary and binary predicate operations on geometries. +""" +from ctypes import c_char, c_char_p, c_double +from django.contrib.gis.geos.libgeos import GEOM_PTR +from django.contrib.gis.geos.prototypes.errcheck import check_predicate +from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc + +## Binary & unary predicate functions ## +def binary_predicate(func, *args): + "For GEOS binary predicate functions." + argtypes = [GEOM_PTR, GEOM_PTR] + if args: argtypes += args + func.argtypes = argtypes + func.restype = c_char + func.errcheck = check_predicate + return func + +def unary_predicate(func): + "For GEOS unary predicate functions." + func.argtypes = [GEOM_PTR] + func.restype = c_char + func.errcheck = check_predicate + return func + +## Unary Predicates ## +geos_hasz = unary_predicate(GEOSFunc('GEOSHasZ')) +geos_isempty = unary_predicate(GEOSFunc('GEOSisEmpty')) +geos_isring = unary_predicate(GEOSFunc('GEOSisRing')) +geos_issimple = unary_predicate(GEOSFunc('GEOSisSimple')) +geos_isvalid = unary_predicate(GEOSFunc('GEOSisValid')) + +## Binary Predicates ## +geos_contains = binary_predicate(GEOSFunc('GEOSContains')) +geos_crosses = binary_predicate(GEOSFunc('GEOSCrosses')) +geos_disjoint = binary_predicate(GEOSFunc('GEOSDisjoint')) +geos_equals = binary_predicate(GEOSFunc('GEOSEquals')) +geos_equalsexact = binary_predicate(GEOSFunc('GEOSEqualsExact'), c_double) +geos_intersects = binary_predicate(GEOSFunc('GEOSIntersects')) +geos_overlaps = binary_predicate(GEOSFunc('GEOSOverlaps')) +geos_relatepattern = binary_predicate(GEOSFunc('GEOSRelatePattern'), c_char_p) +geos_touches = binary_predicate(GEOSFunc('GEOSTouches')) +geos_within = binary_predicate(GEOSFunc('GEOSWithin')) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/prepared.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/prepared.py new file mode 100644 index 0000000..7342d7d --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/prepared.py @@ -0,0 +1,25 @@ +from ctypes import c_char +from django.contrib.gis.geos.libgeos import GEOM_PTR, PREPGEOM_PTR +from django.contrib.gis.geos.prototypes.errcheck import check_predicate +from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc + +# Prepared geometry constructor and destructors. +geos_prepare = GEOSFunc('GEOSPrepare') +geos_prepare.argtypes = [GEOM_PTR] +geos_prepare.restype = PREPGEOM_PTR + +prepared_destroy = GEOSFunc('GEOSPreparedGeom_destroy') +prepared_destroy.argtpes = [PREPGEOM_PTR] +prepared_destroy.restype = None + +# Prepared geometry binary predicate support. +def prepared_predicate(func): + func.argtypes= [PREPGEOM_PTR, GEOM_PTR] + func.restype = c_char + func.errcheck = check_predicate + return func + +prepared_contains = prepared_predicate(GEOSFunc('GEOSPreparedContains')) +prepared_contains_properly = prepared_predicate(GEOSFunc('GEOSPreparedContainsProperly')) +prepared_covers = prepared_predicate(GEOSFunc('GEOSPreparedCovers')) +prepared_intersects = prepared_predicate(GEOSFunc('GEOSPreparedIntersects')) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/threadsafe.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/threadsafe.py new file mode 100644 index 0000000..2c9d25e --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/threadsafe.py @@ -0,0 +1,86 @@ +import threading +from django.contrib.gis.geos.libgeos import lgeos, notice_h, error_h, CONTEXT_PTR + +class GEOSContextHandle(object): + """ + Python object representing a GEOS context handle. + """ + def __init__(self): + # Initializing the context handler for this thread with + # the notice and error handler. + self.ptr = lgeos.initGEOS_r(notice_h, error_h) + + def __del__(self): + if self.ptr: lgeos.finishGEOS_r(self.ptr) + +# Defining a thread-local object and creating an instance +# to hold a reference to GEOSContextHandle for this thread. +class GEOSContext(threading.local): + handle = None + +thread_context = GEOSContext() + +class GEOSFunc(object): + """ + Class that serves as a wrapper for GEOS C Functions, and will + use thread-safe function variants when available. + """ + def __init__(self, func_name): + try: + # GEOS thread-safe function signatures end with '_r', and + # take an additional context handle parameter. + self.cfunc = getattr(lgeos, func_name + '_r') + self.threaded = True + # Create a reference here to thread_context so it's not + # garbage-collected before an attempt to call this object. + self.thread_context = thread_context + except AttributeError: + # Otherwise, use usual function. + self.cfunc = getattr(lgeos, func_name) + self.threaded = False + + def __call__(self, *args): + if self.threaded: + # If a context handle does not exist for this thread, initialize one. + if not self.thread_context.handle: + self.thread_context.handle = GEOSContextHandle() + # Call the threaded GEOS routine with pointer of the context handle + # as the first argument. + return self.cfunc(self.thread_context.handle.ptr, *args) + else: + return self.cfunc(*args) + + def __str__(self): + return self.cfunc.__name__ + + # argtypes property + def _get_argtypes(self): + return self.cfunc.argtypes + + def _set_argtypes(self, argtypes): + if self.threaded: + new_argtypes = [CONTEXT_PTR] + new_argtypes.extend(argtypes) + self.cfunc.argtypes = new_argtypes + else: + self.cfunc.argtypes = argtypes + + argtypes = property(_get_argtypes, _set_argtypes) + + # restype property + def _get_restype(self): + return self.cfunc.restype + + def _set_restype(self, restype): + self.cfunc.restype = restype + + restype = property(_get_restype, _set_restype) + + # errcheck property + def _get_errcheck(self): + return self.cfunc.errcheck + + def _set_errcheck(self, errcheck): + self.cfunc.errcheck = errcheck + + errcheck = property(_get_errcheck, _set_errcheck) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/topology.py b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/topology.py new file mode 100644 index 0000000..dfea3e9 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/prototypes/topology.py @@ -0,0 +1,64 @@ +""" + This module houses the GEOS ctypes prototype functions for the + topological operations on geometries. +""" +__all__ = ['geos_boundary', 'geos_buffer', 'geos_centroid', 'geos_convexhull', + 'geos_difference', 'geos_envelope', 'geos_intersection', + 'geos_linemerge', 'geos_pointonsurface', 'geos_preservesimplify', + 'geos_simplify', 'geos_symdifference', 'geos_union', 'geos_relate'] + +from ctypes import c_double, c_int +from django.contrib.gis.geos.libgeos import geos_version_info, GEOM_PTR, GEOS_PREPARE +from django.contrib.gis.geos.prototypes.errcheck import check_geom, check_minus_one, check_string +from django.contrib.gis.geos.prototypes.geom import geos_char_p +from django.contrib.gis.geos.prototypes.threadsafe import GEOSFunc + +def topology(func, *args, **kwargs): + "For GEOS unary topology functions." + argtypes = [GEOM_PTR] + if args: argtypes += args + func.argtypes = argtypes + func.restype = kwargs.get('restype', GEOM_PTR) + func.errcheck = kwargs.get('errcheck', check_geom) + return func + +### Topology Routines ### +geos_boundary = topology(GEOSFunc('GEOSBoundary')) +geos_buffer = topology(GEOSFunc('GEOSBuffer'), c_double, c_int) +geos_centroid = topology(GEOSFunc('GEOSGetCentroid')) +geos_convexhull = topology(GEOSFunc('GEOSConvexHull')) +geos_difference = topology(GEOSFunc('GEOSDifference'), GEOM_PTR) +geos_envelope = topology(GEOSFunc('GEOSEnvelope')) +geos_intersection = topology(GEOSFunc('GEOSIntersection'), GEOM_PTR) +geos_linemerge = topology(GEOSFunc('GEOSLineMerge')) +geos_pointonsurface = topology(GEOSFunc('GEOSPointOnSurface')) +geos_preservesimplify = topology(GEOSFunc('GEOSTopologyPreserveSimplify'), c_double) +geos_simplify = topology(GEOSFunc('GEOSSimplify'), c_double) +geos_symdifference = topology(GEOSFunc('GEOSSymDifference'), GEOM_PTR) +geos_union = topology(GEOSFunc('GEOSUnion'), GEOM_PTR) + +# GEOSRelate returns a string, not a geometry. +geos_relate = GEOSFunc('GEOSRelate') +geos_relate.argtypes = [GEOM_PTR, GEOM_PTR] +geos_relate.restype = geos_char_p +geos_relate.errcheck = check_string + +# Routines only in GEOS 3.1+ +if GEOS_PREPARE: + geos_cascaded_union = GEOSFunc('GEOSUnionCascaded') + geos_cascaded_union.argtypes = [GEOM_PTR] + geos_cascaded_union.restype = GEOM_PTR + __all__.append('geos_cascaded_union') + +# Linear referencing routines +info = geos_version_info() +if info['version'] >= '3.2.0': + geos_project = topology(GEOSFunc('GEOSProject'), GEOM_PTR, + restype=c_double, errcheck=check_minus_one) + geos_interpolate = topology(GEOSFunc('GEOSInterpolate'), c_double) + + geos_project_normalized = topology(GEOSFunc('GEOSProjectNormalized'), + GEOM_PTR, restype=c_double, errcheck=check_minus_one) + geos_interpolate_normalized = topology(GEOSFunc('GEOSInterpolateNormalized'), c_double) + __all__.extend(['geos_project', 'geos_interpolate', + 'geos_project_normalized', 'geos_interpolate_normalized']) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/__init__.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/__init__.py new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/__init__.py diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos.py new file mode 100644 index 0000000..c8e064b --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos.py @@ -0,0 +1,1108 @@ +from __future__ import unicode_literals + +import ctypes +import json +import random +from binascii import a2b_hex, b2a_hex +from io import BytesIO + +from django.contrib.gis.gdal import HAS_GDAL + +from django.contrib.gis import memoryview +from django.contrib.gis.geometry.test_data import TestDataMixin + +from django.utils.encoding import force_bytes +from django.utils import six +from django.utils.six.moves import xrange +from django.utils import unittest +from django.utils.unittest import skipUnless + +from .. import HAS_GEOS + +if HAS_GEOS: + from .. import (GEOSException, GEOSIndexError, GEOSGeometry, + GeometryCollection, Point, MultiPoint, Polygon, MultiPolygon, LinearRing, + LineString, MultiLineString, fromfile, fromstr, geos_version_info, + GEOS_PREPARE) + from ..base import gdal, numpy, GEOSBase + + +@skipUnless(HAS_GEOS, "Geos is required.") +class GEOSTest(unittest.TestCase, TestDataMixin): + + @property + def null_srid(self): + """ + Returns the proper null SRID depending on the GEOS version. + See the comments in `test_srid` for more details. + """ + info = geos_version_info() + if info['version'] == '3.0.0' and info['release_candidate']: + return -1 + else: + return None + + def test_base(self): + "Tests out the GEOSBase class." + # Testing out GEOSBase class, which provides a `ptr` property + # that abstracts out access to underlying C pointers. + class FakeGeom1(GEOSBase): + pass + + # This one only accepts pointers to floats + c_float_p = ctypes.POINTER(ctypes.c_float) + class FakeGeom2(GEOSBase): + ptr_type = c_float_p + + # Default ptr_type is `c_void_p`. + fg1 = FakeGeom1() + # Default ptr_type is C float pointer + fg2 = FakeGeom2() + + # These assignments are OK -- None is allowed because + # it's equivalent to the NULL pointer. + fg1.ptr = ctypes.c_void_p() + fg1.ptr = None + fg2.ptr = c_float_p(ctypes.c_float(5.23)) + fg2.ptr = None + + # Because pointers have been set to NULL, an exception should be + # raised when we try to access it. Raising an exception is + # preferrable to a segmentation fault that commonly occurs when + # a C method is given a NULL memory reference. + for fg in (fg1, fg2): + # Equivalent to `fg.ptr` + self.assertRaises(GEOSException, fg._get_ptr) + + # Anything that is either not None or the acceptable pointer type will + # result in a TypeError when trying to assign it to the `ptr` property. + # Thus, memmory addresses (integers) and pointers of the incorrect type + # (in `bad_ptrs`) will not be allowed. + bad_ptrs = (5, ctypes.c_char_p(b'foobar')) + for bad_ptr in bad_ptrs: + # Equivalent to `fg.ptr = bad_ptr` + self.assertRaises(TypeError, fg1._set_ptr, bad_ptr) + self.assertRaises(TypeError, fg2._set_ptr, bad_ptr) + + def test_wkt(self): + "Testing WKT output." + for g in self.geometries.wkt_out: + geom = fromstr(g.wkt) + if geom.hasz and geos_version_info()['version'] >= '3.3.0': + self.assertEqual(g.ewkt, geom.wkt) + + def test_hex(self): + "Testing HEX output." + for g in self.geometries.hex_wkt: + geom = fromstr(g.wkt) + self.assertEqual(g.hex, geom.hex.decode()) + + def test_hexewkb(self): + "Testing (HEX)EWKB output." + # For testing HEX(EWKB). + ogc_hex = b'01010000000000000000000000000000000000F03F' + ogc_hex_3d = b'01010000800000000000000000000000000000F03F0000000000000040' + # `SELECT ST_AsHEXEWKB(ST_GeomFromText('POINT(0 1)', 4326));` + hexewkb_2d = b'0101000020E61000000000000000000000000000000000F03F' + # `SELECT ST_AsHEXEWKB(ST_GeomFromEWKT('SRID=4326;POINT(0 1 2)'));` + hexewkb_3d = b'01010000A0E61000000000000000000000000000000000F03F0000000000000040' + + pnt_2d = Point(0, 1, srid=4326) + pnt_3d = Point(0, 1, 2, srid=4326) + + # OGC-compliant HEX will not have SRID value. + self.assertEqual(ogc_hex, pnt_2d.hex) + self.assertEqual(ogc_hex_3d, pnt_3d.hex) + + # HEXEWKB should be appropriate for its dimension -- have to use an + # a WKBWriter w/dimension set accordingly, else GEOS will insert + # garbage into 3D coordinate if there is none. Also, GEOS has a + # a bug in versions prior to 3.1 that puts the X coordinate in + # place of Z; an exception should be raised on those versions. + self.assertEqual(hexewkb_2d, pnt_2d.hexewkb) + if GEOS_PREPARE: + self.assertEqual(hexewkb_3d, pnt_3d.hexewkb) + self.assertEqual(True, GEOSGeometry(hexewkb_3d).hasz) + else: + try: + hexewkb = pnt_3d.hexewkb + except GEOSException: + pass + else: + self.fail('Should have raised GEOSException.') + + # Same for EWKB. + self.assertEqual(memoryview(a2b_hex(hexewkb_2d)), pnt_2d.ewkb) + if GEOS_PREPARE: + self.assertEqual(memoryview(a2b_hex(hexewkb_3d)), pnt_3d.ewkb) + else: + try: + ewkb = pnt_3d.ewkb + except GEOSException: + pass + else: + self.fail('Should have raised GEOSException') + + # Redundant sanity check. + self.assertEqual(4326, GEOSGeometry(hexewkb_2d).srid) + + def test_kml(self): + "Testing KML output." + for tg in self.geometries.wkt_out: + geom = fromstr(tg.wkt) + kml = getattr(tg, 'kml', False) + if kml: self.assertEqual(kml, geom.kml) + + def test_errors(self): + "Testing the Error handlers." + # string-based + for err in self.geometries.errors: + with self.assertRaises((GEOSException, ValueError)): + _ = fromstr(err.wkt) + + # Bad WKB + self.assertRaises(GEOSException, GEOSGeometry, memoryview(b'0')) + + class NotAGeometry(object): + pass + + # Some other object + self.assertRaises(TypeError, GEOSGeometry, NotAGeometry()) + # None + self.assertRaises(TypeError, GEOSGeometry, None) + + def test_wkb(self): + "Testing WKB output." + for g in self.geometries.hex_wkt: + geom = fromstr(g.wkt) + wkb = geom.wkb + self.assertEqual(b2a_hex(wkb).decode().upper(), g.hex) + + def test_create_hex(self): + "Testing creation from HEX." + for g in self.geometries.hex_wkt: + geom_h = GEOSGeometry(g.hex) + # we need to do this so decimal places get normalised + geom_t = fromstr(g.wkt) + self.assertEqual(geom_t.wkt, geom_h.wkt) + + def test_create_wkb(self): + "Testing creation from WKB." + for g in self.geometries.hex_wkt: + wkb = memoryview(a2b_hex(g.hex.encode())) + geom_h = GEOSGeometry(wkb) + # we need to do this so decimal places get normalised + geom_t = fromstr(g.wkt) + self.assertEqual(geom_t.wkt, geom_h.wkt) + + def test_ewkt(self): + "Testing EWKT." + srids = (-1, 32140) + for srid in srids: + for p in self.geometries.polygons: + ewkt = 'SRID=%d;%s' % (srid, p.wkt) + poly = fromstr(ewkt) + self.assertEqual(srid, poly.srid) + self.assertEqual(srid, poly.shell.srid) + self.assertEqual(srid, fromstr(poly.ewkt).srid) # Checking export + + @skipUnless(HAS_GDAL, "GDAL is required.") + def test_json(self): + "Testing GeoJSON input/output (via GDAL)." + for g in self.geometries.json_geoms: + geom = GEOSGeometry(g.wkt) + if not hasattr(g, 'not_equal'): + # Loading jsons to prevent decimal differences + self.assertEqual(json.loads(g.json), json.loads(geom.json)) + self.assertEqual(json.loads(g.json), json.loads(geom.geojson)) + self.assertEqual(GEOSGeometry(g.wkt), GEOSGeometry(geom.json)) + + def test_fromfile(self): + "Testing the fromfile() factory." + ref_pnt = GEOSGeometry('POINT(5 23)') + + wkt_f = BytesIO() + wkt_f.write(force_bytes(ref_pnt.wkt)) + wkb_f = BytesIO() + wkb_f.write(bytes(ref_pnt.wkb)) + + # Other tests use `fromfile()` on string filenames so those + # aren't tested here. + for fh in (wkt_f, wkb_f): + fh.seek(0) + pnt = fromfile(fh) + self.assertEqual(ref_pnt, pnt) + + def test_eq(self): + "Testing equivalence." + p = fromstr('POINT(5 23)') + self.assertEqual(p, p.wkt) + self.assertNotEqual(p, 'foo') + ls = fromstr('LINESTRING(0 0, 1 1, 5 5)') + self.assertEqual(ls, ls.wkt) + self.assertNotEqual(p, 'bar') + # Error shouldn't be raise on equivalence testing with + # an invalid type. + for g in (p, ls): + self.assertNotEqual(g, None) + self.assertNotEqual(g, {'foo' : 'bar'}) + self.assertNotEqual(g, False) + + def test_points(self): + "Testing Point objects." + prev = fromstr('POINT(0 0)') + for p in self.geometries.points: + # Creating the point from the WKT + pnt = fromstr(p.wkt) + self.assertEqual(pnt.geom_type, 'Point') + self.assertEqual(pnt.geom_typeid, 0) + self.assertEqual(p.x, pnt.x) + self.assertEqual(p.y, pnt.y) + self.assertEqual(True, pnt == fromstr(p.wkt)) + self.assertEqual(False, pnt == prev) + + # Making sure that the point's X, Y components are what we expect + self.assertAlmostEqual(p.x, pnt.tuple[0], 9) + self.assertAlmostEqual(p.y, pnt.tuple[1], 9) + + # Testing the third dimension, and getting the tuple arguments + if hasattr(p, 'z'): + self.assertEqual(True, pnt.hasz) + self.assertEqual(p.z, pnt.z) + self.assertEqual(p.z, pnt.tuple[2], 9) + tup_args = (p.x, p.y, p.z) + set_tup1 = (2.71, 3.14, 5.23) + set_tup2 = (5.23, 2.71, 3.14) + else: + self.assertEqual(False, pnt.hasz) + self.assertEqual(None, pnt.z) + tup_args = (p.x, p.y) + set_tup1 = (2.71, 3.14) + set_tup2 = (3.14, 2.71) + + # Centroid operation on point should be point itself + self.assertEqual(p.centroid, pnt.centroid.tuple) + + # Now testing the different constructors + pnt2 = Point(tup_args) # e.g., Point((1, 2)) + pnt3 = Point(*tup_args) # e.g., Point(1, 2) + self.assertEqual(True, pnt == pnt2) + self.assertEqual(True, pnt == pnt3) + + # Now testing setting the x and y + pnt.y = 3.14 + pnt.x = 2.71 + self.assertEqual(3.14, pnt.y) + self.assertEqual(2.71, pnt.x) + + # Setting via the tuple/coords property + pnt.tuple = set_tup1 + self.assertEqual(set_tup1, pnt.tuple) + pnt.coords = set_tup2 + self.assertEqual(set_tup2, pnt.coords) + + prev = pnt # setting the previous geometry + + def test_multipoints(self): + "Testing MultiPoint objects." + for mp in self.geometries.multipoints: + mpnt = fromstr(mp.wkt) + self.assertEqual(mpnt.geom_type, 'MultiPoint') + self.assertEqual(mpnt.geom_typeid, 4) + + self.assertAlmostEqual(mp.centroid[0], mpnt.centroid.tuple[0], 9) + self.assertAlmostEqual(mp.centroid[1], mpnt.centroid.tuple[1], 9) + + self.assertRaises(GEOSIndexError, mpnt.__getitem__, len(mpnt)) + self.assertEqual(mp.centroid, mpnt.centroid.tuple) + self.assertEqual(mp.coords, tuple(m.tuple for m in mpnt)) + for p in mpnt: + self.assertEqual(p.geom_type, 'Point') + self.assertEqual(p.geom_typeid, 0) + self.assertEqual(p.empty, False) + self.assertEqual(p.valid, True) + + def test_linestring(self): + "Testing LineString objects." + prev = fromstr('POINT(0 0)') + for l in self.geometries.linestrings: + ls = fromstr(l.wkt) + self.assertEqual(ls.geom_type, 'LineString') + self.assertEqual(ls.geom_typeid, 1) + self.assertEqual(ls.empty, False) + self.assertEqual(ls.ring, False) + if hasattr(l, 'centroid'): + self.assertEqual(l.centroid, ls.centroid.tuple) + if hasattr(l, 'tup'): + self.assertEqual(l.tup, ls.tuple) + + self.assertEqual(True, ls == fromstr(l.wkt)) + self.assertEqual(False, ls == prev) + self.assertRaises(GEOSIndexError, ls.__getitem__, len(ls)) + prev = ls + + # Creating a LineString from a tuple, list, and numpy array + self.assertEqual(ls, LineString(ls.tuple)) # tuple + self.assertEqual(ls, LineString(*ls.tuple)) # as individual arguments + self.assertEqual(ls, LineString([list(tup) for tup in ls.tuple])) # as list + self.assertEqual(ls.wkt, LineString(*tuple(Point(tup) for tup in ls.tuple)).wkt) # Point individual arguments + if numpy: self.assertEqual(ls, LineString(numpy.array(ls.tuple))) # as numpy array + + def test_multilinestring(self): + "Testing MultiLineString objects." + prev = fromstr('POINT(0 0)') + for l in self.geometries.multilinestrings: + ml = fromstr(l.wkt) + self.assertEqual(ml.geom_type, 'MultiLineString') + self.assertEqual(ml.geom_typeid, 5) + + self.assertAlmostEqual(l.centroid[0], ml.centroid.x, 9) + self.assertAlmostEqual(l.centroid[1], ml.centroid.y, 9) + + self.assertEqual(True, ml == fromstr(l.wkt)) + self.assertEqual(False, ml == prev) + prev = ml + + for ls in ml: + self.assertEqual(ls.geom_type, 'LineString') + self.assertEqual(ls.geom_typeid, 1) + self.assertEqual(ls.empty, False) + + self.assertRaises(GEOSIndexError, ml.__getitem__, len(ml)) + self.assertEqual(ml.wkt, MultiLineString(*tuple(s.clone() for s in ml)).wkt) + self.assertEqual(ml, MultiLineString(*tuple(LineString(s.tuple) for s in ml))) + + def test_linearring(self): + "Testing LinearRing objects." + for rr in self.geometries.linearrings: + lr = fromstr(rr.wkt) + self.assertEqual(lr.geom_type, 'LinearRing') + self.assertEqual(lr.geom_typeid, 2) + self.assertEqual(rr.n_p, len(lr)) + self.assertEqual(True, lr.valid) + self.assertEqual(False, lr.empty) + + # Creating a LinearRing from a tuple, list, and numpy array + self.assertEqual(lr, LinearRing(lr.tuple)) + self.assertEqual(lr, LinearRing(*lr.tuple)) + self.assertEqual(lr, LinearRing([list(tup) for tup in lr.tuple])) + if numpy: self.assertEqual(lr, LinearRing(numpy.array(lr.tuple))) + + def test_polygons_from_bbox(self): + "Testing `from_bbox` class method." + bbox = (-180, -90, 180, 90) + p = Polygon.from_bbox(bbox) + self.assertEqual(bbox, p.extent) + + # Testing numerical precision + x = 3.14159265358979323 + bbox = (0, 0, 1, x) + p = Polygon.from_bbox(bbox) + y = p.extent[-1] + self.assertEqual(format(x, '.13f'), format(y, '.13f')) + + def test_polygons(self): + "Testing Polygon objects." + + prev = fromstr('POINT(0 0)') + for p in self.geometries.polygons: + # Creating the Polygon, testing its properties. + poly = fromstr(p.wkt) + self.assertEqual(poly.geom_type, 'Polygon') + self.assertEqual(poly.geom_typeid, 3) + self.assertEqual(poly.empty, False) + self.assertEqual(poly.ring, False) + self.assertEqual(p.n_i, poly.num_interior_rings) + self.assertEqual(p.n_i + 1, len(poly)) # Testing __len__ + self.assertEqual(p.n_p, poly.num_points) + + # Area & Centroid + self.assertAlmostEqual(p.area, poly.area, 9) + self.assertAlmostEqual(p.centroid[0], poly.centroid.tuple[0], 9) + self.assertAlmostEqual(p.centroid[1], poly.centroid.tuple[1], 9) + + # Testing the geometry equivalence + self.assertEqual(True, poly == fromstr(p.wkt)) + self.assertEqual(False, poly == prev) # Should not be equal to previous geometry + self.assertEqual(True, poly != prev) + + # Testing the exterior ring + ring = poly.exterior_ring + self.assertEqual(ring.geom_type, 'LinearRing') + self.assertEqual(ring.geom_typeid, 2) + if p.ext_ring_cs: + self.assertEqual(p.ext_ring_cs, ring.tuple) + self.assertEqual(p.ext_ring_cs, poly[0].tuple) # Testing __getitem__ + + # Testing __getitem__ and __setitem__ on invalid indices + self.assertRaises(GEOSIndexError, poly.__getitem__, len(poly)) + self.assertRaises(GEOSIndexError, poly.__setitem__, len(poly), False) + self.assertRaises(GEOSIndexError, poly.__getitem__, -1 * len(poly) - 1) + + # Testing __iter__ + for r in poly: + self.assertEqual(r.geom_type, 'LinearRing') + self.assertEqual(r.geom_typeid, 2) + + # Testing polygon construction. + self.assertRaises(TypeError, Polygon, 0, [1, 2, 3]) + self.assertRaises(TypeError, Polygon, 'foo') + + # Polygon(shell, (hole1, ... holeN)) + rings = tuple(r for r in poly) + self.assertEqual(poly, Polygon(rings[0], rings[1:])) + + # Polygon(shell_tuple, hole_tuple1, ... , hole_tupleN) + ring_tuples = tuple(r.tuple for r in poly) + self.assertEqual(poly, Polygon(*ring_tuples)) + + # Constructing with tuples of LinearRings. + self.assertEqual(poly.wkt, Polygon(*tuple(r for r in poly)).wkt) + self.assertEqual(poly.wkt, Polygon(*tuple(LinearRing(r.tuple) for r in poly)).wkt) + + def test_polygon_comparison(self): + p1 = Polygon(((0, 0), (0, 1), (1, 1), (1, 0), (0, 0))) + p2 = Polygon(((0, 0), (0, 1), (1, 0), (0, 0))) + self.assertTrue(p1 > p2) + self.assertFalse(p1 < p2) + self.assertFalse(p2 > p1) + self.assertTrue(p2 < p1) + + p3 = Polygon(((0, 0), (0, 1), (1, 1), (2, 0), (0, 0))) + p4 = Polygon(((0, 0), (0, 1), (2, 2), (1, 0), (0, 0))) + self.assertFalse(p4 < p3) + self.assertTrue(p3 < p4) + self.assertTrue(p4 > p3) + self.assertFalse(p3 > p4) + + def test_multipolygons(self): + "Testing MultiPolygon objects." + prev = fromstr('POINT (0 0)') + for mp in self.geometries.multipolygons: + mpoly = fromstr(mp.wkt) + self.assertEqual(mpoly.geom_type, 'MultiPolygon') + self.assertEqual(mpoly.geom_typeid, 6) + self.assertEqual(mp.valid, mpoly.valid) + + if mp.valid: + self.assertEqual(mp.num_geom, mpoly.num_geom) + self.assertEqual(mp.n_p, mpoly.num_coords) + self.assertEqual(mp.num_geom, len(mpoly)) + self.assertRaises(GEOSIndexError, mpoly.__getitem__, len(mpoly)) + for p in mpoly: + self.assertEqual(p.geom_type, 'Polygon') + self.assertEqual(p.geom_typeid, 3) + self.assertEqual(p.valid, True) + self.assertEqual(mpoly.wkt, MultiPolygon(*tuple(poly.clone() for poly in mpoly)).wkt) + + def test_memory_hijinks(self): + "Testing Geometry __del__() on rings and polygons." + #### Memory issues with rings and polygons + + # These tests are needed to ensure sanity with writable geometries. + + # Getting a polygon with interior rings, and pulling out the interior rings + poly = fromstr(self.geometries.polygons[1].wkt) + ring1 = poly[0] + ring2 = poly[1] + + # These deletes should be 'harmless' since they are done on child geometries + del ring1 + del ring2 + ring1 = poly[0] + ring2 = poly[1] + + # Deleting the polygon + del poly + + # Access to these rings is OK since they are clones. + s1, s2 = str(ring1), str(ring2) + + def test_coord_seq(self): + "Testing Coordinate Sequence objects." + for p in self.geometries.polygons: + if p.ext_ring_cs: + # Constructing the polygon and getting the coordinate sequence + poly = fromstr(p.wkt) + cs = poly.exterior_ring.coord_seq + + self.assertEqual(p.ext_ring_cs, cs.tuple) # done in the Polygon test too. + self.assertEqual(len(p.ext_ring_cs), len(cs)) # Making sure __len__ works + + # Checks __getitem__ and __setitem__ + for i in xrange(len(p.ext_ring_cs)): + c1 = p.ext_ring_cs[i] # Expected value + c2 = cs[i] # Value from coordseq + self.assertEqual(c1, c2) + + # Constructing the test value to set the coordinate sequence with + if len(c1) == 2: tset = (5, 23) + else: tset = (5, 23, 8) + cs[i] = tset + + # Making sure every set point matches what we expect + for j in range(len(tset)): + cs[i] = tset + self.assertEqual(tset[j], cs[i][j]) + + def test_relate_pattern(self): + "Testing relate() and relate_pattern()." + g = fromstr('POINT (0 0)') + self.assertRaises(GEOSException, g.relate_pattern, 0, 'invalid pattern, yo') + for rg in self.geometries.relate_geoms: + a = fromstr(rg.wkt_a) + b = fromstr(rg.wkt_b) + self.assertEqual(rg.result, a.relate_pattern(b, rg.pattern)) + self.assertEqual(rg.pattern, a.relate(b)) + + def test_intersection(self): + "Testing intersects() and intersection()." + for i in xrange(len(self.geometries.topology_geoms)): + a = fromstr(self.geometries.topology_geoms[i].wkt_a) + b = fromstr(self.geometries.topology_geoms[i].wkt_b) + i1 = fromstr(self.geometries.intersect_geoms[i].wkt) + self.assertEqual(True, a.intersects(b)) + i2 = a.intersection(b) + self.assertEqual(i1, i2) + self.assertEqual(i1, a & b) # __and__ is intersection operator + a &= b # testing __iand__ + self.assertEqual(i1, a) + + def test_union(self): + "Testing union()." + for i in xrange(len(self.geometries.topology_geoms)): + a = fromstr(self.geometries.topology_geoms[i].wkt_a) + b = fromstr(self.geometries.topology_geoms[i].wkt_b) + u1 = fromstr(self.geometries.union_geoms[i].wkt) + u2 = a.union(b) + self.assertEqual(u1, u2) + self.assertEqual(u1, a | b) # __or__ is union operator + a |= b # testing __ior__ + self.assertEqual(u1, a) + + def test_difference(self): + "Testing difference()." + for i in xrange(len(self.geometries.topology_geoms)): + a = fromstr(self.geometries.topology_geoms[i].wkt_a) + b = fromstr(self.geometries.topology_geoms[i].wkt_b) + d1 = fromstr(self.geometries.diff_geoms[i].wkt) + d2 = a.difference(b) + self.assertEqual(d1, d2) + self.assertEqual(d1, a - b) # __sub__ is difference operator + a -= b # testing __isub__ + self.assertEqual(d1, a) + + def test_symdifference(self): + "Testing sym_difference()." + for i in xrange(len(self.geometries.topology_geoms)): + a = fromstr(self.geometries.topology_geoms[i].wkt_a) + b = fromstr(self.geometries.topology_geoms[i].wkt_b) + d1 = fromstr(self.geometries.sdiff_geoms[i].wkt) + d2 = a.sym_difference(b) + self.assertEqual(d1, d2) + self.assertEqual(d1, a ^ b) # __xor__ is symmetric difference operator + a ^= b # testing __ixor__ + self.assertEqual(d1, a) + + def test_buffer(self): + "Testing buffer()." + for bg in self.geometries.buffer_geoms: + g = fromstr(bg.wkt) + + # The buffer we expect + exp_buf = fromstr(bg.buffer_wkt) + quadsegs = bg.quadsegs + width = bg.width + + # Can't use a floating-point for the number of quadsegs. + self.assertRaises(ctypes.ArgumentError, g.buffer, width, float(quadsegs)) + + # Constructing our buffer + buf = g.buffer(width, quadsegs) + self.assertEqual(exp_buf.num_coords, buf.num_coords) + self.assertEqual(len(exp_buf), len(buf)) + + # Now assuring that each point in the buffer is almost equal + for j in xrange(len(exp_buf)): + exp_ring = exp_buf[j] + buf_ring = buf[j] + self.assertEqual(len(exp_ring), len(buf_ring)) + for k in xrange(len(exp_ring)): + # Asserting the X, Y of each point are almost equal (due to floating point imprecision) + self.assertAlmostEqual(exp_ring[k][0], buf_ring[k][0], 9) + self.assertAlmostEqual(exp_ring[k][1], buf_ring[k][1], 9) + + def test_srid(self): + "Testing the SRID property and keyword." + # Testing SRID keyword on Point + pnt = Point(5, 23, srid=4326) + self.assertEqual(4326, pnt.srid) + pnt.srid = 3084 + self.assertEqual(3084, pnt.srid) + self.assertRaises(ctypes.ArgumentError, pnt.set_srid, '4326') + + # Testing SRID keyword on fromstr(), and on Polygon rings. + poly = fromstr(self.geometries.polygons[1].wkt, srid=4269) + self.assertEqual(4269, poly.srid) + for ring in poly: self.assertEqual(4269, ring.srid) + poly.srid = 4326 + self.assertEqual(4326, poly.shell.srid) + + # Testing SRID keyword on GeometryCollection + gc = GeometryCollection(Point(5, 23), LineString((0, 0), (1.5, 1.5), (3, 3)), srid=32021) + self.assertEqual(32021, gc.srid) + for i in range(len(gc)): self.assertEqual(32021, gc[i].srid) + + # GEOS may get the SRID from HEXEWKB + # 'POINT(5 23)' at SRID=4326 in hex form -- obtained from PostGIS + # using `SELECT GeomFromText('POINT (5 23)', 4326);`. + hex = '0101000020E610000000000000000014400000000000003740' + p1 = fromstr(hex) + self.assertEqual(4326, p1.srid) + + # In GEOS 3.0.0rc1-4 when the EWKB and/or HEXEWKB is exported, + # the SRID information is lost and set to -1 -- this is not a + # problem on the 3.0.0 version (another reason to upgrade). + exp_srid = self.null_srid + + p2 = fromstr(p1.hex) + self.assertEqual(exp_srid, p2.srid) + p3 = fromstr(p1.hex, srid=-1) # -1 is intended. + self.assertEqual(-1, p3.srid) + + @skipUnless(HAS_GDAL, "GDAL is required.") + def test_custom_srid(self): + """ Test with a srid unknown from GDAL """ + pnt = Point(111200, 220900, srid=999999) + self.assertTrue(pnt.ewkt.startswith("SRID=999999;POINT (111200.0")) + self.assertIsInstance(pnt.ogr, gdal.OGRGeometry) + self.assertIsNone(pnt.srs) + + # Test conversion from custom to a known srid + c2w = gdal.CoordTransform( + gdal.SpatialReference('+proj=mill +lat_0=0 +lon_0=0 +x_0=0 +y_0=0 +R_A +ellps=WGS84 +datum=WGS84 +units=m +no_defs'), + gdal.SpatialReference(4326)) + new_pnt = pnt.transform(c2w, clone=True) + self.assertEqual(new_pnt.srid, 4326) + self.assertAlmostEqual(new_pnt.x, 1, 3) + self.assertAlmostEqual(new_pnt.y, 2, 3) + + def test_mutable_geometries(self): + "Testing the mutability of Polygons and Geometry Collections." + ### Testing the mutability of Polygons ### + for p in self.geometries.polygons: + poly = fromstr(p.wkt) + + # Should only be able to use __setitem__ with LinearRing geometries. + self.assertRaises(TypeError, poly.__setitem__, 0, LineString((1, 1), (2, 2))) + + # Constructing the new shell by adding 500 to every point in the old shell. + shell_tup = poly.shell.tuple + new_coords = [] + for point in shell_tup: new_coords.append((point[0] + 500., point[1] + 500.)) + new_shell = LinearRing(*tuple(new_coords)) + + # Assigning polygon's exterior ring w/the new shell + poly.exterior_ring = new_shell + s = str(new_shell) # new shell is still accessible + self.assertEqual(poly.exterior_ring, new_shell) + self.assertEqual(poly[0], new_shell) + + ### Testing the mutability of Geometry Collections + for tg in self.geometries.multipoints: + mp = fromstr(tg.wkt) + for i in range(len(mp)): + # Creating a random point. + pnt = mp[i] + new = Point(random.randint(21, 100), random.randint(21, 100)) + # Testing the assignment + mp[i] = new + s = str(new) # what was used for the assignment is still accessible + self.assertEqual(mp[i], new) + self.assertEqual(mp[i].wkt, new.wkt) + self.assertNotEqual(pnt, mp[i]) + + # MultiPolygons involve much more memory management because each + # Polygon w/in the collection has its own rings. + for tg in self.geometries.multipolygons: + mpoly = fromstr(tg.wkt) + for i in xrange(len(mpoly)): + poly = mpoly[i] + old_poly = mpoly[i] + # Offsetting the each ring in the polygon by 500. + for j in xrange(len(poly)): + r = poly[j] + for k in xrange(len(r)): r[k] = (r[k][0] + 500., r[k][1] + 500.) + poly[j] = r + + self.assertNotEqual(mpoly[i], poly) + # Testing the assignment + mpoly[i] = poly + s = str(poly) # Still accessible + self.assertEqual(mpoly[i], poly) + self.assertNotEqual(mpoly[i], old_poly) + + # Extreme (!!) __setitem__ -- no longer works, have to detect + # in the first object that __setitem__ is called in the subsequent + # objects -- maybe mpoly[0, 0, 0] = (3.14, 2.71)? + #mpoly[0][0][0] = (3.14, 2.71) + #self.assertEqual((3.14, 2.71), mpoly[0][0][0]) + # Doing it more slowly.. + #self.assertEqual((3.14, 2.71), mpoly[0].shell[0]) + #del mpoly + + def test_threed(self): + "Testing three-dimensional geometries." + # Testing a 3D Point + pnt = Point(2, 3, 8) + self.assertEqual((2.,3.,8.), pnt.coords) + self.assertRaises(TypeError, pnt.set_coords, (1.,2.)) + pnt.coords = (1.,2.,3.) + self.assertEqual((1.,2.,3.), pnt.coords) + + # Testing a 3D LineString + ls = LineString((2., 3., 8.), (50., 250., -117.)) + self.assertEqual(((2.,3.,8.), (50.,250.,-117.)), ls.tuple) + self.assertRaises(TypeError, ls.__setitem__, 0, (1.,2.)) + ls[0] = (1.,2.,3.) + self.assertEqual((1.,2.,3.), ls[0]) + + def test_distance(self): + "Testing the distance() function." + # Distance to self should be 0. + pnt = Point(0, 0) + self.assertEqual(0.0, pnt.distance(Point(0, 0))) + + # Distance should be 1 + self.assertEqual(1.0, pnt.distance(Point(0, 1))) + + # Distance should be ~ sqrt(2) + self.assertAlmostEqual(1.41421356237, pnt.distance(Point(1, 1)), 11) + + # Distances are from the closest vertex in each geometry -- + # should be 3 (distance from (2, 2) to (5, 2)). + ls1 = LineString((0, 0), (1, 1), (2, 2)) + ls2 = LineString((5, 2), (6, 1), (7, 0)) + self.assertEqual(3, ls1.distance(ls2)) + + def test_length(self): + "Testing the length property." + # Points have 0 length. + pnt = Point(0, 0) + self.assertEqual(0.0, pnt.length) + + # Should be ~ sqrt(2) + ls = LineString((0, 0), (1, 1)) + self.assertAlmostEqual(1.41421356237, ls.length, 11) + + # Should be circumfrence of Polygon + poly = Polygon(LinearRing((0, 0), (0, 1), (1, 1), (1, 0), (0, 0))) + self.assertEqual(4.0, poly.length) + + # Should be sum of each element's length in collection. + mpoly = MultiPolygon(poly.clone(), poly) + self.assertEqual(8.0, mpoly.length) + + def test_emptyCollections(self): + "Testing empty geometries and collections." + gc1 = GeometryCollection([]) + gc2 = fromstr('GEOMETRYCOLLECTION EMPTY') + pnt = fromstr('POINT EMPTY') + ls = fromstr('LINESTRING EMPTY') + poly = fromstr('POLYGON EMPTY') + mls = fromstr('MULTILINESTRING EMPTY') + mpoly1 = fromstr('MULTIPOLYGON EMPTY') + mpoly2 = MultiPolygon(()) + + for g in [gc1, gc2, pnt, ls, poly, mls, mpoly1, mpoly2]: + self.assertEqual(True, g.empty) + + # Testing len() and num_geom. + if isinstance(g, Polygon): + self.assertEqual(1, len(g)) # Has one empty linear ring + self.assertEqual(1, g.num_geom) + self.assertEqual(0, len(g[0])) + elif isinstance(g, (Point, LineString)): + self.assertEqual(1, g.num_geom) + self.assertEqual(0, len(g)) + else: + self.assertEqual(0, g.num_geom) + self.assertEqual(0, len(g)) + + # Testing __getitem__ (doesn't work on Point or Polygon) + if isinstance(g, Point): + self.assertRaises(GEOSIndexError, g.get_x) + elif isinstance(g, Polygon): + lr = g.shell + self.assertEqual('LINEARRING EMPTY', lr.wkt) + self.assertEqual(0, len(lr)) + self.assertEqual(True, lr.empty) + self.assertRaises(GEOSIndexError, lr.__getitem__, 0) + else: + self.assertRaises(GEOSIndexError, g.__getitem__, 0) + + def test_collections_of_collections(self): + "Testing GeometryCollection handling of other collections." + # Creating a GeometryCollection WKT string composed of other + # collections and polygons. + coll = [mp.wkt for mp in self.geometries.multipolygons if mp.valid] + coll.extend([mls.wkt for mls in self.geometries.multilinestrings]) + coll.extend([p.wkt for p in self.geometries.polygons]) + coll.extend([mp.wkt for mp in self.geometries.multipoints]) + gc_wkt = 'GEOMETRYCOLLECTION(%s)' % ','.join(coll) + + # Should construct ok from WKT + gc1 = GEOSGeometry(gc_wkt) + + # Should also construct ok from individual geometry arguments. + gc2 = GeometryCollection(*tuple(g for g in gc1)) + + # And, they should be equal. + self.assertEqual(gc1, gc2) + + @skipUnless(HAS_GDAL, "GDAL is required.") + def test_gdal(self): + "Testing `ogr` and `srs` properties." + g1 = fromstr('POINT(5 23)') + self.assertIsInstance(g1.ogr, gdal.OGRGeometry) + self.assertIsNone(g1.srs) + + if GEOS_PREPARE: + g1_3d = fromstr('POINT(5 23 8)') + self.assertIsInstance(g1_3d.ogr, gdal.OGRGeometry) + self.assertEqual(g1_3d.ogr.z, 8) + + g2 = fromstr('LINESTRING(0 0, 5 5, 23 23)', srid=4326) + self.assertIsInstance(g2.ogr, gdal.OGRGeometry) + self.assertIsInstance(g2.srs, gdal.SpatialReference) + self.assertEqual(g2.hex, g2.ogr.hex) + self.assertEqual('WGS 84', g2.srs.name) + + def test_copy(self): + "Testing use with the Python `copy` module." + import copy + poly = GEOSGeometry('POLYGON((0 0, 0 23, 23 23, 23 0, 0 0), (5 5, 5 10, 10 10, 10 5, 5 5))') + cpy1 = copy.copy(poly) + cpy2 = copy.deepcopy(poly) + self.assertNotEqual(poly._ptr, cpy1._ptr) + self.assertNotEqual(poly._ptr, cpy2._ptr) + + @skipUnless(HAS_GDAL, "GDAL is required to transform geometries") + def test_transform(self): + "Testing `transform` method." + orig = GEOSGeometry('POINT (-104.609 38.255)', 4326) + trans = GEOSGeometry('POINT (992385.4472045 481455.4944650)', 2774) + + # Using a srid, a SpatialReference object, and a CoordTransform object + # for transformations. + t1, t2, t3 = orig.clone(), orig.clone(), orig.clone() + t1.transform(trans.srid) + t2.transform(gdal.SpatialReference('EPSG:2774')) + ct = gdal.CoordTransform(gdal.SpatialReference('WGS84'), gdal.SpatialReference(2774)) + t3.transform(ct) + + # Testing use of the `clone` keyword. + k1 = orig.clone() + k2 = k1.transform(trans.srid, clone=True) + self.assertEqual(k1, orig) + self.assertNotEqual(k1, k2) + + prec = 3 + for p in (t1, t2, t3, k2): + self.assertAlmostEqual(trans.x, p.x, prec) + self.assertAlmostEqual(trans.y, p.y, prec) + + @skipUnless(HAS_GDAL, "GDAL is required to transform geometries") + def test_transform_3d(self): + p3d = GEOSGeometry('POINT (5 23 100)', 4326) + p3d.transform(2774) + if GEOS_PREPARE: + self.assertEqual(p3d.z, 100) + else: + self.assertIsNone(p3d.z) + + @skipUnless(HAS_GDAL, "GDAL is required.") + def test_transform_noop(self): + """ Testing `transform` method (SRID match) """ + # transform() should no-op if source & dest SRIDs match, + # regardless of whether GDAL is available. + if gdal.HAS_GDAL: + g = GEOSGeometry('POINT (-104.609 38.255)', 4326) + gt = g.tuple + g.transform(4326) + self.assertEqual(g.tuple, gt) + self.assertEqual(g.srid, 4326) + + g = GEOSGeometry('POINT (-104.609 38.255)', 4326) + g1 = g.transform(4326, clone=True) + self.assertEqual(g1.tuple, g.tuple) + self.assertEqual(g1.srid, 4326) + self.assertTrue(g1 is not g, "Clone didn't happen") + + old_has_gdal = gdal.HAS_GDAL + try: + gdal.HAS_GDAL = False + + g = GEOSGeometry('POINT (-104.609 38.255)', 4326) + gt = g.tuple + g.transform(4326) + self.assertEqual(g.tuple, gt) + self.assertEqual(g.srid, 4326) + + g = GEOSGeometry('POINT (-104.609 38.255)', 4326) + g1 = g.transform(4326, clone=True) + self.assertEqual(g1.tuple, g.tuple) + self.assertEqual(g1.srid, 4326) + self.assertTrue(g1 is not g, "Clone didn't happen") + finally: + gdal.HAS_GDAL = old_has_gdal + + def test_transform_nosrid(self): + """ Testing `transform` method (no SRID or negative SRID) """ + + g = GEOSGeometry('POINT (-104.609 38.255)', srid=None) + self.assertRaises(GEOSException, g.transform, 2774) + + g = GEOSGeometry('POINT (-104.609 38.255)', srid=None) + self.assertRaises(GEOSException, g.transform, 2774, clone=True) + + g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1) + self.assertRaises(GEOSException, g.transform, 2774) + + g = GEOSGeometry('POINT (-104.609 38.255)', srid=-1) + self.assertRaises(GEOSException, g.transform, 2774, clone=True) + + @skipUnless(HAS_GDAL, "GDAL is required.") + def test_transform_nogdal(self): + """ Testing `transform` method (GDAL not available) """ + old_has_gdal = gdal.HAS_GDAL + try: + gdal.HAS_GDAL = False + + g = GEOSGeometry('POINT (-104.609 38.255)', 4326) + self.assertRaises(GEOSException, g.transform, 2774) + + g = GEOSGeometry('POINT (-104.609 38.255)', 4326) + self.assertRaises(GEOSException, g.transform, 2774, clone=True) + finally: + gdal.HAS_GDAL = old_has_gdal + + def test_extent(self): + "Testing `extent` method." + # The xmin, ymin, xmax, ymax of the MultiPoint should be returned. + mp = MultiPoint(Point(5, 23), Point(0, 0), Point(10, 50)) + self.assertEqual((0.0, 0.0, 10.0, 50.0), mp.extent) + pnt = Point(5.23, 17.8) + # Extent of points is just the point itself repeated. + self.assertEqual((5.23, 17.8, 5.23, 17.8), pnt.extent) + # Testing on the 'real world' Polygon. + poly = fromstr(self.geometries.polygons[3].wkt) + ring = poly.shell + x, y = ring.x, ring.y + xmin, ymin = min(x), min(y) + xmax, ymax = max(x), max(y) + self.assertEqual((xmin, ymin, xmax, ymax), poly.extent) + + def test_pickle(self): + "Testing pickling and unpickling support." + # Using both pickle and cPickle -- just 'cause. + from django.utils.six.moves import cPickle + import pickle + + # Creating a list of test geometries for pickling, + # and setting the SRID on some of them. + def get_geoms(lst, srid=None): + return [GEOSGeometry(tg.wkt, srid) for tg in lst] + tgeoms = get_geoms(self.geometries.points) + tgeoms.extend(get_geoms(self.geometries.multilinestrings, 4326)) + tgeoms.extend(get_geoms(self.geometries.polygons, 3084)) + tgeoms.extend(get_geoms(self.geometries.multipolygons, 900913)) + + # The SRID won't be exported in GEOS 3.0 release candidates. + no_srid = self.null_srid == -1 + for geom in tgeoms: + s1, s2 = cPickle.dumps(geom), pickle.dumps(geom) + g1, g2 = cPickle.loads(s1), pickle.loads(s2) + for tmpg in (g1, g2): + self.assertEqual(geom, tmpg) + if not no_srid: self.assertEqual(geom.srid, tmpg.srid) + + @skipUnless(HAS_GEOS and GEOS_PREPARE, "geos >= 3.1.0 is required") + def test_prepared(self): + "Testing PreparedGeometry support." + # Creating a simple multipolygon and getting a prepared version. + mpoly = GEOSGeometry('MULTIPOLYGON(((0 0,0 5,5 5,5 0,0 0)),((5 5,5 10,10 10,10 5,5 5)))') + prep = mpoly.prepared + + # A set of test points. + pnts = [Point(5, 5), Point(7.5, 7.5), Point(2.5, 7.5)] + covers = [True, True, False] # No `covers` op for regular GEOS geoms. + for pnt, c in zip(pnts, covers): + # Results should be the same (but faster) + self.assertEqual(mpoly.contains(pnt), prep.contains(pnt)) + self.assertEqual(mpoly.intersects(pnt), prep.intersects(pnt)) + self.assertEqual(c, prep.covers(pnt)) + + # Original geometry deletion should not crash the prepared one (#21662) + del mpoly + self.assertTrue(prep.covers(Point(5, 5))) + + def test_line_merge(self): + "Testing line merge support" + ref_geoms = (fromstr('LINESTRING(1 1, 1 1, 3 3)'), + fromstr('MULTILINESTRING((1 1, 3 3), (3 3, 4 2))'), + ) + ref_merged = (fromstr('LINESTRING(1 1, 3 3)'), + fromstr('LINESTRING (1 1, 3 3, 4 2)'), + ) + for geom, merged in zip(ref_geoms, ref_merged): + self.assertEqual(merged, geom.merged) + + @skipUnless(HAS_GEOS and GEOS_PREPARE, "geos >= 3.1.0 is required") + def test_valid_reason(self): + "Testing IsValidReason support" + + g = GEOSGeometry("POINT(0 0)") + self.assertTrue(g.valid) + self.assertIsInstance(g.valid_reason, six.string_types) + self.assertEqual(g.valid_reason, "Valid Geometry") + + g = GEOSGeometry("LINESTRING(0 0, 0 0)") + + self.assertFalse(g.valid) + self.assertIsInstance(g.valid_reason, six.string_types) + self.assertTrue(g.valid_reason.startswith("Too few points in geometry component")) + + @skipUnless(HAS_GEOS and geos_version_info()['version'] >= '3.2.0', "geos >= 3.2.0 is required") + def test_linearref(self): + "Testing linear referencing" + + ls = fromstr('LINESTRING(0 0, 0 10, 10 10, 10 0)') + mls = fromstr('MULTILINESTRING((0 0, 0 10), (10 0, 10 10))') + + self.assertEqual(ls.project(Point(0, 20)), 10.0) + self.assertEqual(ls.project(Point(7, 6)), 24) + self.assertEqual(ls.project_normalized(Point(0, 20)), 1.0/3) + + self.assertEqual(ls.interpolate(10), Point(0, 10)) + self.assertEqual(ls.interpolate(24), Point(10, 6)) + self.assertEqual(ls.interpolate_normalized(1.0/3), Point(0, 10)) + + self.assertEqual(mls.project(Point(0, 20)), 10) + self.assertEqual(mls.project(Point(7, 6)), 16) + + self.assertEqual(mls.interpolate(9), Point(0, 9)) + self.assertEqual(mls.interpolate(17), Point(10, 7)) + + def test_geos_version(self): + """Testing the GEOS version regular expression.""" + from django.contrib.gis.geos.libgeos import version_regex + versions = [('3.0.0rc4-CAPI-1.3.3', '3.0.0', '1.3.3'), + ('3.0.0-CAPI-1.4.1', '3.0.0', '1.4.1'), + ('3.4.0dev-CAPI-1.8.0', '3.4.0', '1.8.0'), + ('3.4.0dev-CAPI-1.8.0 r0', '3.4.0', '1.8.0')] + for v_init, v_geos, v_capi in versions: + m = version_regex.match(v_init) + self.assertTrue(m, msg="Unable to parse the version string '%s'" % v_init) + self.assertEqual(m.group('version'), v_geos) + self.assertEqual(m.group('capi_version'), v_capi) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos_mutation.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos_mutation.py new file mode 100644 index 0000000..40b708a --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_geos_mutation.py @@ -0,0 +1,134 @@ +# Copyright (c) 2008-2009 Aryeh Leib Taurog, all rights reserved. +# Modified from original contribution by Aryeh Leib Taurog, which was +# released under the New BSD license. + +from django.utils import unittest +from django.utils.unittest import skipUnless + +from .. import HAS_GEOS + +if HAS_GEOS: + from .. import * + from ..error import GEOSIndexError + + +def getItem(o,i): return o[i] +def delItem(o,i): del o[i] +def setItem(o,i,v): o[i] = v + +if HAS_GEOS: + def api_get_distance(x): return x.distance(Point(-200,-200)) + +def api_get_buffer(x): return x.buffer(10) +def api_get_geom_typeid(x): return x.geom_typeid +def api_get_num_coords(x): return x.num_coords +def api_get_centroid(x): return x.centroid +def api_get_empty(x): return x.empty +def api_get_valid(x): return x.valid +def api_get_simple(x): return x.simple +def api_get_ring(x): return x.ring +def api_get_boundary(x): return x.boundary +def api_get_convex_hull(x): return x.convex_hull +def api_get_extent(x): return x.extent +def api_get_area(x): return x.area +def api_get_length(x): return x.length + +geos_function_tests = [ val for name, val in vars().items() + if hasattr(val, '__call__') + and name.startswith('api_get_') ] + + +@skipUnless(HAS_GEOS, "Geos is required.") +class GEOSMutationTest(unittest.TestCase): + """ + Tests Pythonic Mutability of Python GEOS geometry wrappers + get/set/delitem on a slice, normal list methods + """ + + def test00_GEOSIndexException(self): + 'Testing Geometry GEOSIndexError' + p = Point(1,2) + for i in range(-2,2): p._checkindex(i) + self.assertRaises(GEOSIndexError, p._checkindex, 2) + self.assertRaises(GEOSIndexError, p._checkindex, -3) + + def test01_PointMutations(self): + 'Testing Point mutations' + for p in (Point(1,2,3), fromstr('POINT (1 2 3)')): + self.assertEqual(p._get_single_external(1), 2.0, 'Point _get_single_external') + + # _set_single + p._set_single(0,100) + self.assertEqual(p.coords, (100.0,2.0,3.0), 'Point _set_single') + + # _set_list + p._set_list(2,(50,3141)) + self.assertEqual(p.coords, (50.0,3141.0), 'Point _set_list') + + def test02_PointExceptions(self): + 'Testing Point exceptions' + self.assertRaises(TypeError, Point, range(1)) + self.assertRaises(TypeError, Point, range(4)) + + def test03_PointApi(self): + 'Testing Point API' + q = Point(4,5,3) + for p in (Point(1,2,3), fromstr('POINT (1 2 3)')): + p[0:2] = [4,5] + for f in geos_function_tests: + self.assertEqual(f(q), f(p), 'Point ' + f.__name__) + + def test04_LineStringMutations(self): + 'Testing LineString mutations' + for ls in (LineString((1,0),(4,1),(6,-1)), + fromstr('LINESTRING (1 0,4 1,6 -1)')): + self.assertEqual(ls._get_single_external(1), (4.0,1.0), 'LineString _get_single_external') + + # _set_single + ls._set_single(0,(-50,25)) + self.assertEqual(ls.coords, ((-50.0,25.0),(4.0,1.0),(6.0,-1.0)), 'LineString _set_single') + + # _set_list + ls._set_list(2, ((-50.0,25.0),(6.0,-1.0))) + self.assertEqual(ls.coords, ((-50.0,25.0),(6.0,-1.0)), 'LineString _set_list') + + lsa = LineString(ls.coords) + for f in geos_function_tests: + self.assertEqual(f(lsa), f(ls), 'LineString ' + f.__name__) + + def test05_Polygon(self): + 'Testing Polygon mutations' + for pg in (Polygon(((1,0),(4,1),(6,-1),(8,10),(1,0)), + ((5,4),(6,4),(6,3),(5,4))), + fromstr('POLYGON ((1 0,4 1,6 -1,8 10,1 0),(5 4,6 4,6 3,5 4))')): + self.assertEqual(pg._get_single_external(0), + LinearRing((1,0),(4,1),(6,-1),(8,10),(1,0)), + 'Polygon _get_single_external(0)') + self.assertEqual(pg._get_single_external(1), + LinearRing((5,4),(6,4),(6,3),(5,4)), + 'Polygon _get_single_external(1)') + + # _set_list + pg._set_list(2, (((1,2),(10,0),(12,9),(-1,15),(1,2)), + ((4,2),(5,2),(5,3),(4,2)))) + self.assertEqual(pg.coords, + (((1.0,2.0),(10.0,0.0),(12.0,9.0),(-1.0,15.0),(1.0,2.0)), + ((4.0,2.0),(5.0,2.0),(5.0,3.0),(4.0,2.0))), + 'Polygon _set_list') + + lsa = Polygon(*pg.coords) + for f in geos_function_tests: + self.assertEqual(f(lsa), f(pg), 'Polygon ' + f.__name__) + + def test06_Collection(self): + 'Testing Collection mutations' + for mp in (MultiPoint(*map(Point,((3,4),(-1,2),(5,-4),(2,8)))), + fromstr('MULTIPOINT (3 4,-1 2,5 -4,2 8)')): + self.assertEqual(mp._get_single_external(2), Point(5,-4), 'Collection _get_single_external') + + mp._set_list(3, map(Point,((5,5),(3,-2),(8,1)))) + self.assertEqual(mp.coords, ((5.0,5.0),(3.0,-2.0),(8.0,1.0)), 'Collection _set_list') + + lsa = MultiPoint(*map(Point,((5,5),(3,-2),(8,1)))) + for f in geos_function_tests: + self.assertEqual(f(lsa), f(mp), 'MultiPoint ' + f.__name__) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_io.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_io.py new file mode 100644 index 0000000..34eeaf9 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_io.py @@ -0,0 +1,116 @@ +from __future__ import unicode_literals + +import binascii +import unittest + +from django.contrib.gis import memoryview +from django.utils.unittest import skipUnless + +from ..import HAS_GEOS + +if HAS_GEOS: + from .. import GEOSGeometry, WKTReader, WKTWriter, WKBReader, WKBWriter, geos_version_info + + +@skipUnless(HAS_GEOS, "Geos is required.") +class GEOSIOTest(unittest.TestCase): + + def test01_wktreader(self): + # Creating a WKTReader instance + wkt_r = WKTReader() + wkt = 'POINT (5 23)' + + # read() should return a GEOSGeometry + ref = GEOSGeometry(wkt) + g1 = wkt_r.read(wkt.encode()) + g2 = wkt_r.read(wkt) + + for geom in (g1, g2): + self.assertEqual(ref, geom) + + # Should only accept six.string_types objects. + self.assertRaises(TypeError, wkt_r.read, 1) + self.assertRaises(TypeError, wkt_r.read, memoryview(b'foo')) + + def test02_wktwriter(self): + # Creating a WKTWriter instance, testing its ptr property. + wkt_w = WKTWriter() + self.assertRaises(TypeError, wkt_w._set_ptr, WKTReader.ptr_type()) + + ref = GEOSGeometry('POINT (5 23)') + ref_wkt = 'POINT (5.0000000000000000 23.0000000000000000)' + self.assertEqual(ref_wkt, wkt_w.write(ref).decode()) + + def test03_wkbreader(self): + # Creating a WKBReader instance + wkb_r = WKBReader() + + hex = b'000000000140140000000000004037000000000000' + wkb = memoryview(binascii.a2b_hex(hex)) + ref = GEOSGeometry(hex) + + # read() should return a GEOSGeometry on either a hex string or + # a WKB buffer. + g1 = wkb_r.read(wkb) + g2 = wkb_r.read(hex) + for geom in (g1, g2): + self.assertEqual(ref, geom) + + bad_input = (1, 5.23, None, False) + for bad_wkb in bad_input: + self.assertRaises(TypeError, wkb_r.read, bad_wkb) + + def test04_wkbwriter(self): + wkb_w = WKBWriter() + + # Representations of 'POINT (5 23)' in hex -- one normal and + # the other with the byte order changed. + g = GEOSGeometry('POINT (5 23)') + hex1 = b'010100000000000000000014400000000000003740' + wkb1 = memoryview(binascii.a2b_hex(hex1)) + hex2 = b'000000000140140000000000004037000000000000' + wkb2 = memoryview(binascii.a2b_hex(hex2)) + + self.assertEqual(hex1, wkb_w.write_hex(g)) + self.assertEqual(wkb1, wkb_w.write(g)) + + # Ensuring bad byteorders are not accepted. + for bad_byteorder in (-1, 2, 523, 'foo', None): + # Equivalent of `wkb_w.byteorder = bad_byteorder` + self.assertRaises(ValueError, wkb_w._set_byteorder, bad_byteorder) + + # Setting the byteorder to 0 (for Big Endian) + wkb_w.byteorder = 0 + self.assertEqual(hex2, wkb_w.write_hex(g)) + self.assertEqual(wkb2, wkb_w.write(g)) + + # Back to Little Endian + wkb_w.byteorder = 1 + + # Now, trying out the 3D and SRID flags. + g = GEOSGeometry('POINT (5 23 17)') + g.srid = 4326 + + hex3d = b'0101000080000000000000144000000000000037400000000000003140' + wkb3d = memoryview(binascii.a2b_hex(hex3d)) + hex3d_srid = b'01010000A0E6100000000000000000144000000000000037400000000000003140' + wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid)) + + # Ensuring bad output dimensions are not accepted + for bad_outdim in (-1, 0, 1, 4, 423, 'foo', None): + # Equivalent of `wkb_w.outdim = bad_outdim` + self.assertRaises(ValueError, wkb_w._set_outdim, bad_outdim) + + # These tests will fail on 3.0.0 because of a bug that was fixed in 3.1: + # http://trac.osgeo.org/geos/ticket/216 + if not geos_version_info()['version'].startswith('3.0.'): + # Now setting the output dimensions to be 3 + wkb_w.outdim = 3 + + self.assertEqual(hex3d, wkb_w.write_hex(g)) + self.assertEqual(wkb3d, wkb_w.write(g)) + + # Telling the WKBWriter to include the srid in the representation. + wkb_w.srid = True + self.assertEqual(hex3d_srid, wkb_w.write_hex(g)) + self.assertEqual(wkb3d_srid, wkb_w.write(g)) diff --git a/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_mutable_list.py b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_mutable_list.py new file mode 100644 index 0000000..a4a56f2 --- /dev/null +++ b/lib/python2.7/site-packages/django/contrib/gis/geos/tests/test_mutable_list.py @@ -0,0 +1,397 @@ +# Copyright (c) 2008-2009 Aryeh Leib Taurog, http://www.aryehleib.com +# All rights reserved. +# +# Modified from original contribution by Aryeh Leib Taurog, which was +# released under the New BSD license. +from django.contrib.gis.geos.mutable_list import ListMixin +from django.utils import six +from django.utils import unittest + + +class UserListA(ListMixin): + _mytype = tuple + def __init__(self, i_list, *args, **kwargs): + self._list = self._mytype(i_list) + super(UserListA, self).__init__(*args, **kwargs) + + def __len__(self): return len(self._list) + + def __str__(self): return str(self._list) + + def __repr__(self): return repr(self._list) + + def _set_list(self, length, items): + # this would work: + # self._list = self._mytype(items) + # but then we wouldn't be testing length parameter + itemList = ['x'] * length + for i, v in enumerate(items): + itemList[i] = v + + self._list = self._mytype(itemList) + + def _get_single_external(self, index): + return self._list[index] + +class UserListB(UserListA): + _mytype = list + + def _set_single(self, index, value): + self._list[index] = value + +def nextRange(length): + nextRange.start += 100 + return range(nextRange.start, nextRange.start + length) + +nextRange.start = 0 + +class ListMixinTest(unittest.TestCase): + """ + Tests base class ListMixin by comparing a list clone which is + a ListMixin subclass with a real Python list. + """ + limit = 3 + listType = UserListA + + def lists_of_len(self, length=None): + if length is None: length = self.limit + pl = list(range(length)) + return pl, self.listType(pl) + + def limits_plus(self, b): + return range(-self.limit - b, self.limit + b) + + def step_range(self): + return list(range(-1 - self.limit, 0)) + list(range(1, 1 + self.limit)) + + def test01_getslice(self): + 'Slice retrieval' + pl, ul = self.lists_of_len() + for i in self.limits_plus(1): + self.assertEqual(pl[i:], ul[i:], 'slice [%d:]' % (i)) + self.assertEqual(pl[:i], ul[:i], 'slice [:%d]' % (i)) + + for j in self.limits_plus(1): + self.assertEqual(pl[i:j], ul[i:j], 'slice [%d:%d]' % (i,j)) + for k in self.step_range(): + self.assertEqual(pl[i:j:k], ul[i:j:k], 'slice [%d:%d:%d]' % (i,j,k)) + + for k in self.step_range(): + self.assertEqual(pl[i::k], ul[i::k], 'slice [%d::%d]' % (i,k)) + self.assertEqual(pl[:i:k], ul[:i:k], 'slice [:%d:%d]' % (i,k)) + + for k in self.step_range(): + self.assertEqual(pl[::k], ul[::k], 'slice [::%d]' % (k)) + + def test02_setslice(self): + 'Slice assignment' + def setfcn(x,i,j,k,L): x[i:j:k] = range(L) + pl, ul = self.lists_of_len() + for slen in range(self.limit + 1): + ssl = nextRange(slen) + ul[:] = ssl + pl[:] = ssl + self.assertEqual(pl, ul[:], 'set slice [:]') + + for i in self.limits_plus(1): + ssl = nextRange(slen) + ul[i:] = ssl + pl[i:] = ssl + self.assertEqual(pl, ul[:], 'set slice [%d:]' % (i)) + + ssl = nextRange(slen) + ul[:i] = ssl + pl[:i] = ssl + self.assertEqual(pl, ul[:], 'set slice [:%d]' % (i)) + + for j in self.limits_plus(1): + ssl = nextRange(slen) + ul[i:j] = ssl + pl[i:j] = ssl + self.assertEqual(pl, ul[:], 'set slice [%d:%d]' % (i, j)) + + for k in self.step_range(): + ssl = nextRange( len(ul[i:j:k]) ) + ul[i:j:k] = ssl + pl[i:j:k] = ssl + self.assertEqual(pl, ul[:], 'set slice [%d:%d:%d]' % (i, j, k)) + + sliceLen = len(ul[i:j:k]) + self.assertRaises(ValueError, setfcn, ul, i, j, k, sliceLen + 1) + if sliceLen > 2: + self.assertRaises(ValueError, setfcn, ul, i, j, k, sliceLen - 1) + + for k in self.step_range(): + ssl = nextRange( len(ul[i::k]) ) + ul[i::k] = ssl + pl[i::k] = ssl + self.assertEqual(pl, ul[:], 'set slice [%d::%d]' % (i, k)) + + ssl = nextRange( len(ul[:i:k]) ) + ul[:i:k] = ssl + pl[:i:k] = ssl + self.assertEqual(pl, ul[:], 'set slice [:%d:%d]' % (i, k)) + + for k in self.step_range(): + ssl = nextRange(len(ul[::k])) + ul[::k] = ssl + pl[::k] = ssl + self.assertEqual(pl, ul[:], 'set slice [::%d]' % (k)) + + + def test03_delslice(self): + 'Delete slice' + for Len in range(self.limit): + pl, ul = self.lists_of_len(Len) + del pl[:] + del ul[:] + self.assertEqual(pl[:], ul[:], 'del slice [:]') + for i in range(-Len - 1, Len + 1): + pl, ul = self.lists_of_len(Len) + del pl[i:] + del ul[i:] + self.assertEqual(pl[:], ul[:], 'del slice [%d:]' % (i)) + pl, ul = self.lists_of_len(Len) + del pl[:i] + del ul[:i] + self.assertEqual(pl[:], ul[:], 'del slice [:%d]' % (i)) + for j in range(-Len - 1, Len + 1): + pl, ul = self.lists_of_len(Len) + del pl[i:j] + del ul[i:j] + self.assertEqual(pl[:], ul[:], 'del slice [%d:%d]' % (i,j)) + for k in list(range(-Len - 1, 0)) + list(range(1, Len)): + pl, ul = self.lists_of_len(Len) + del pl[i:j:k] + del ul[i:j:k] + self.assertEqual(pl[:], ul[:], 'del slice [%d:%d:%d]' % (i,j,k)) + + for k in list(range(-Len - 1, 0)) + list(range(1, Len)): + pl, ul = self.lists_of_len(Len) + del pl[:i:k] + del ul[:i:k] + self.assertEqual(pl[:], ul[:], 'del slice [:%d:%d]' % (i,k)) + + pl, ul = self.lists_of_len(Len) + del pl[i::k] + del ul[i::k] + self.assertEqual(pl[:], ul[:], 'del slice [%d::%d]' % (i,k)) + + for k in list(range(-Len - 1, 0)) + list(range(1, Len)): + pl, ul = self.lists_of_len(Len) + del pl[::k] + del ul[::k] + self.assertEqual(pl[:], ul[:], 'del slice [::%d]' % (k)) + + def test04_get_set_del_single(self): + 'Get/set/delete single item' + pl, ul = self.lists_of_len() + for i in self.limits_plus(0): + self.assertEqual(pl[i], ul[i], 'get single item [%d]' % i) + + for i in self.limits_plus(0): + pl, ul = self.lists_of_len() + pl[i] = 100 + ul[i] = 100 + self.assertEqual(pl[:], ul[:], 'set single item [%d]' % i) + + for i in self.limits_plus(0): + pl, ul = self.lists_of_len() + del pl[i] + del ul[i] + self.assertEqual(pl[:], ul[:], 'del single item [%d]' % i) + + def test05_out_of_range_exceptions(self): + 'Out of range exceptions' + def setfcn(x, i): x[i] = 20 + def getfcn(x, i): return x[i] + def delfcn(x, i): del x[i] + pl, ul = self.lists_of_len() + for i in (-1 - self.limit, self.limit): + self.assertRaises(IndexError, setfcn, ul, i) # 'set index %d' % i) + self.assertRaises(IndexError, getfcn, ul, i) # 'get index %d' % i) + self.assertRaises(IndexError, delfcn, ul, i) # 'del index %d' % i) + + def test06_list_methods(self): + 'List methods' + pl, ul = self.lists_of_len() + pl.append(40) + ul.append(40) + self.assertEqual(pl[:], ul[:], 'append') + + pl.extend(range(50,55)) + ul.extend(range(50,55)) + self.assertEqual(pl[:], ul[:], 'extend') + + pl.reverse() + ul.reverse() + self.assertEqual(pl[:], ul[:], 'reverse') + + for i in self.limits_plus(1): + pl, ul = self.lists_of_len() + pl.insert(i,50) + ul.insert(i,50) + self.assertEqual(pl[:], ul[:], 'insert at %d' % i) + + for i in self.limits_plus(0): + pl, ul = self.lists_of_len() + self.assertEqual(pl.pop(i), ul.pop(i), 'popped value at %d' % i) + self.assertEqual(pl[:], ul[:], 'after pop at %d' % i) + + pl, ul = self.lists_of_len() + self.assertEqual(pl.pop(), ul.pop(i), 'popped value') + self.assertEqual(pl[:], ul[:], 'after pop') + + pl, ul = self.lists_of_len() + def popfcn(x, i): x.pop(i) + self.assertRaises(IndexError, popfcn, ul, self.limit) + self.assertRaises(IndexError, popfcn, ul, -1 - self.limit) + + pl, ul = self.lists_of_len() + for val in range(self.limit): + self.assertEqual(pl.index(val), ul.index(val), 'index of %d' % val) + + for val in self.limits_plus(2): + self.assertEqual(pl.count(val), ul.count(val), 'count %d' % val) + + for val in range(self.limit): + pl, ul = self.lists_of_len() + pl.remove(val) + ul.remove(val) + self.assertEqual(pl[:], ul[:], 'after remove val %d' % val) + + def indexfcn(x, v): return x.index(v) + def removefcn(x, v): return x.remove(v) + self.assertRaises(ValueError, indexfcn, ul, 40) + self.assertRaises(ValueError, removefcn, ul, 40) + + def test07_allowed_types(self): + 'Type-restricted list' + pl, ul = self.lists_of_len() + ul._allowed = six.integer_types + ul[1] = 50 + ul[:2] = [60, 70, 80] + def setfcn(x, i, v): x[i] = v + self.assertRaises(TypeError, setfcn, ul, 2, 'hello') + self.assertRaises(TypeError, setfcn, ul, slice(0,3,2), ('hello','goodbye')) + + def test08_min_length(self): + 'Length limits' + pl, ul = self.lists_of_len() + ul._minlength = 1 + def delfcn(x,i): del x[:i] + def setfcn(x,i): x[:i] = [] + for i in range(self.limit - ul._minlength + 1, self.limit + 1): + self.assertRaises(ValueError, delfcn, ul, i) + self.assertRaises(ValueError, setfcn, ul, i) + del ul[:ul._minlength] + + ul._maxlength = 4 + for i in range(0, ul._maxlength - len(ul)): + ul.append(i) + self.assertRaises(ValueError, ul.append, 10) + + def test09_iterable_check(self): + 'Error on assigning non-iterable to slice' + pl, ul = self.lists_of_len(self.limit + 1) + def setfcn(x, i, v): x[i] = v + self.assertRaises(TypeError, setfcn, ul, slice(0,3,2), 2) + + def test10_checkindex(self): + 'Index check' + pl, ul = self.lists_of_len() + for i in self.limits_plus(0): + if i < 0: + self.assertEqual(ul._checkindex(i), i + self.limit, '_checkindex(neg index)') + else: + self.assertEqual(ul._checkindex(i), i, '_checkindex(pos index)') + + for i in (-self.limit - 1, self.limit): + self.assertRaises(IndexError, ul._checkindex, i) + + ul._IndexError = TypeError + self.assertRaises(TypeError, ul._checkindex, -self.limit - 1) + + def test_11_sorting(self): + 'Sorting' + pl, ul = self.lists_of_len() + pl.insert(0, pl.pop()) + ul.insert(0, ul.pop()) + pl.sort() + ul.sort() + self.assertEqual(pl[:], ul[:], 'sort') + mid = pl[len(pl) // 2] + pl.sort(key=lambda x: (mid-x)**2) + ul.sort(key=lambda x: (mid-x)**2) + self.assertEqual(pl[:], ul[:], 'sort w/ key') + + pl.insert(0, pl.pop()) + ul.insert(0, ul.pop()) + pl.sort(reverse=True) + ul.sort(reverse=True) + self.assertEqual(pl[:], ul[:], 'sort w/ reverse') + mid = pl[len(pl) // 2] + pl.sort(key=lambda x: (mid-x)**2) + ul.sort(key=lambda x: (mid-x)**2) + self.assertEqual(pl[:], ul[:], 'sort w/ key') + + def test_12_arithmetic(self): + 'Arithmetic' + pl, ul = self.lists_of_len() + al = list(range(10,14)) + self.assertEqual(list(pl + al), list(ul + al), 'add') + self.assertEqual(type(ul), type(ul + al), 'type of add result') + self.assertEqual(list(al + pl), list(al + ul), 'radd') + self.assertEqual(type(al), type(al + ul), 'type of radd result') + objid = id(ul) + pl += al + ul += al + self.assertEqual(pl[:], ul[:], 'in-place add') + self.assertEqual(objid, id(ul), 'in-place add id') + + for n in (-1,0,1,3): + pl, ul = self.lists_of_len() + self.assertEqual(list(pl * n), list(ul * n), 'mul by %d' % n) + self.assertEqual(type(ul), type(ul * n), 'type of mul by %d result' % n) + self.assertEqual(list(n * pl), list(n * ul), 'rmul by %d' % n) + self.assertEqual(type(ul), type(n * ul), 'type of rmul by %d result' % n) + objid = id(ul) + pl *= n + ul *= n + self.assertEqual(pl[:], ul[:], 'in-place mul by %d' % n) + self.assertEqual(objid, id(ul), 'in-place mul by %d id' % n) + + pl, ul = self.lists_of_len() + self.assertEqual(pl, ul, 'cmp for equal') + self.assertFalse(ul == pl + [2], 'cmp for not equal') + self.assertTrue(pl >= ul, 'cmp for gte self') + self.assertTrue(pl <= ul, 'cmp for lte self') + self.assertTrue(ul >= pl, 'cmp for self gte') + self.assertTrue(ul <= pl, 'cmp for self lte') + + self.assertTrue(pl + [5] > ul, 'cmp') + self.assertTrue(pl + [5] >= ul, 'cmp') + self.assertTrue(pl < ul + [2], 'cmp') + self.assertTrue(pl <= ul + [2], 'cmp') + self.assertTrue(ul + [5] > pl, 'cmp') + self.assertTrue(ul + [5] >= pl, 'cmp') + self.assertTrue(ul < pl + [2], 'cmp') + self.assertTrue(ul <= pl + [2], 'cmp') + + # Also works with a custom IndexError + ul_longer = ul + [2] + ul_longer._IndexError = TypeError + ul._IndexError = TypeError + self.assertFalse(ul_longer == pl) + self.assertFalse(ul == ul_longer) + self.assertTrue(ul_longer > ul) + + pl[1] = 20 + self.assertTrue(pl > ul, 'cmp for gt self') + self.assertTrue(ul < pl, 'cmp for self lt') + pl[1] = -20 + self.assertTrue(pl < ul, 'cmp for lt self') + self.assertTrue(pl < ul, 'cmp for lt self') + +class ListMixinTestSingle(ListMixinTest): + listType = UserListB |