| """ |
| Base/mixin classes for the spatial backend database operations and the |
| `SpatialRefSys` model the backend. |
| """ |
| import re |
| from django.conf import settings |
| from django.contrib.gis import gdal |
| |
| class BaseSpatialOperations(object): |
| """ |
| This module holds the base `BaseSpatialBackend` object, which is |
| instantiated by each spatial database backend with the features |
| it has. |
| """ |
| distance_functions = {} |
| geometry_functions = {} |
| geometry_operators = {} |
| geography_operators = {} |
| geography_functions = {} |
| gis_terms = {} |
| truncate_params = {} |
| |
| # Quick booleans for the type of this spatial backend, and |
| # an attribute for the spatial database version tuple (if applicable) |
| postgis = False |
| spatialite = False |
| mysql = False |
| oracle = False |
| spatial_version = None |
| |
| # How the geometry column should be selected. |
| select = None |
| |
| # Does the spatial database have a geography type? |
| geography = False |
| |
| area = False |
| centroid = False |
| difference = False |
| distance = False |
| distance_sphere = False |
| distance_spheroid = False |
| envelope = False |
| force_rhr = False |
| mem_size = False |
| bounding_circle = False |
| num_geom = False |
| num_points = False |
| perimeter = False |
| perimeter3d = False |
| point_on_surface = False |
| polygonize = False |
| reverse = False |
| scale = False |
| snap_to_grid = False |
| sym_difference = False |
| transform = False |
| translate = False |
| union = False |
| |
| # Aggregates |
| collect = False |
| extent = False |
| extent3d = False |
| make_line = False |
| unionagg = False |
| |
| # Serialization |
| geohash = False |
| geojson = False |
| gml = False |
| kml = False |
| svg = False |
| |
| # Constructors |
| from_text = False |
| from_wkb = False |
| |
| # Default conversion functions for aggregates; will be overridden if implemented |
| # for the spatial backend. |
| def convert_extent(self, box): |
| raise NotImplementedError('Aggregate extent not implemented for this spatial backend.') |
| |
| def convert_extent3d(self, box): |
| raise NotImplementedError('Aggregate 3D extent not implemented for this spatial backend.') |
| |
| def convert_geom(self, geom_val, geom_field): |
| raise NotImplementedError('Aggregate method not implemented for this spatial backend.') |
| |
| # For quoting column values, rather than columns. |
| def geo_quote_name(self, name): |
| if isinstance(name, unicode): |
| name = name.encode('ascii') |
| return "'%s'" % name |
| |
| # GeometryField operations |
| def geo_db_type(self, f): |
| """ |
| Returns the database column type for the geometry field on |
| the spatial backend. |
| """ |
| raise NotImplementedError |
| |
| def get_distance(self, f, value, lookup_type): |
| """ |
| Returns the distance parameters for the given geometry field, |
| lookup value, and lookup type. |
| """ |
| raise NotImplementedError('Distance operations not available on this spatial backend.') |
| |
| def get_geom_placeholder(self, f, value): |
| """ |
| Returns the placeholder for the given geometry field with the given |
| value. Depending on the spatial backend, the placeholder may contain a |
| stored procedure call to the transformation function of the spatial |
| backend. |
| """ |
| raise NotImplementedError |
| |
| # Spatial SQL Construction |
| def spatial_aggregate_sql(self, agg): |
| raise NotImplementedError('Aggregate support not implemented for this spatial backend.') |
| |
| def spatial_lookup_sql(self, lvalue, lookup_type, value, field): |
| raise NotImplmentedError |
| |
| # Routines for getting the OGC-compliant models. |
| def geometry_columns(self): |
| raise NotImplementedError |
| |
| def spatial_ref_sys(self): |
| raise NotImplementedError |
| |
| class SpatialRefSysMixin(object): |
| """ |
| The SpatialRefSysMixin is a class used by the database-dependent |
| SpatialRefSys objects to reduce redundnant code. |
| """ |
| # For pulling out the spheroid from the spatial reference string. This |
| # regular expression is used only if the user does not have GDAL installed. |
| # TODO: Flattening not used in all ellipsoids, could also be a minor axis, |
| # or 'b' parameter. |
| spheroid_regex = re.compile(r'.+SPHEROID\[\"(?P<name>.+)\",(?P<major>\d+(\.\d+)?),(?P<flattening>\d{3}\.\d+),') |
| |
| # For pulling out the units on platforms w/o GDAL installed. |
| # TODO: Figure out how to pull out angular units of projected coordinate system and |
| # fix for LOCAL_CS types. GDAL should be highly recommended for performing |
| # distance queries. |
| units_regex = re.compile(r'.+UNIT ?\["(?P<unit_name>[\w \'\(\)]+)", ?(?P<unit>[\d\.]+)(,AUTHORITY\["(?P<unit_auth_name>[\w \'\(\)]+)","(?P<unit_auth_val>\d+)"\])?\]([\w ]+)?(,AUTHORITY\["(?P<auth_name>[\w \'\(\)]+)","(?P<auth_val>\d+)"\])?\]$') |
| |
| @property |
| def srs(self): |
| """ |
| Returns a GDAL SpatialReference object, if GDAL is installed. |
| """ |
| if gdal.HAS_GDAL: |
| # TODO: Is caching really necessary here? Is complexity worth it? |
| if hasattr(self, '_srs'): |
| # Returning a clone of the cached SpatialReference object. |
| return self._srs.clone() |
| else: |
| # Attempting to cache a SpatialReference object. |
| |
| # Trying to get from WKT first. |
| try: |
| self._srs = gdal.SpatialReference(self.wkt) |
| return self.srs |
| except Exception, msg: |
| pass |
| |
| try: |
| self._srs = gdal.SpatialReference(self.proj4text) |
| return self.srs |
| except Exception, msg: |
| pass |
| |
| raise Exception('Could not get OSR SpatialReference from WKT: %s\nError:\n%s' % (self.wkt, msg)) |
| else: |
| raise Exception('GDAL is not installed.') |
| |
| @property |
| def ellipsoid(self): |
| """ |
| Returns a tuple of the ellipsoid parameters: |
| (semimajor axis, semiminor axis, and inverse flattening). |
| """ |
| if gdal.HAS_GDAL: |
| return self.srs.ellipsoid |
| else: |
| m = self.spheroid_regex.match(self.wkt) |
| if m: return (float(m.group('major')), float(m.group('flattening'))) |
| else: return None |
| |
| @property |
| def name(self): |
| "Returns the projection name." |
| return self.srs.name |
| |
| @property |
| def spheroid(self): |
| "Returns the spheroid name for this spatial reference." |
| return self.srs['spheroid'] |
| |
| @property |
| def datum(self): |
| "Returns the datum for this spatial reference." |
| return self.srs['datum'] |
| |
| @property |
| def projected(self): |
| "Is this Spatial Reference projected?" |
| if gdal.HAS_GDAL: |
| return self.srs.projected |
| else: |
| return self.wkt.startswith('PROJCS') |
| |
| @property |
| def local(self): |
| "Is this Spatial Reference local?" |
| if gdal.HAS_GDAL: |
| return self.srs.local |
| else: |
| return self.wkt.startswith('LOCAL_CS') |
| |
| @property |
| def geographic(self): |
| "Is this Spatial Reference geographic?" |
| if gdal.HAS_GDAL: |
| return self.srs.geographic |
| else: |
| return self.wkt.startswith('GEOGCS') |
| |
| @property |
| def linear_name(self): |
| "Returns the linear units name." |
| if gdal.HAS_GDAL: |
| return self.srs.linear_name |
| elif self.geographic: |
| return None |
| else: |
| m = self.units_regex.match(self.wkt) |
| return m.group('unit_name') |
| |
| @property |
| def linear_units(self): |
| "Returns the linear units." |
| if gdal.HAS_GDAL: |
| return self.srs.linear_units |
| elif self.geographic: |
| return None |
| else: |
| m = self.units_regex.match(self.wkt) |
| return m.group('unit') |
| |
| @property |
| def angular_name(self): |
| "Returns the name of the angular units." |
| if gdal.HAS_GDAL: |
| return self.srs.angular_name |
| elif self.projected: |
| return None |
| else: |
| m = self.units_regex.match(self.wkt) |
| return m.group('unit_name') |
| |
| @property |
| def angular_units(self): |
| "Returns the angular units." |
| if gdal.HAS_GDAL: |
| return self.srs.angular_units |
| elif self.projected: |
| return None |
| else: |
| m = self.units_regex.match(self.wkt) |
| return m.group('unit') |
| |
| @property |
| def units(self): |
| "Returns a tuple of the units and the name." |
| if self.projected or self.local: |
| return (self.linear_units, self.linear_name) |
| elif self.geographic: |
| return (self.angular_units, self.angular_name) |
| else: |
| return (None, None) |
| |
| @classmethod |
| def get_units(cls, wkt): |
| """ |
| Class method used by GeometryField on initialization to |
| retrive the units on the given WKT, without having to use |
| any of the database fields. |
| """ |
| if gdal.HAS_GDAL: |
| return gdal.SpatialReference(wkt).units |
| else: |
| m = cls.units_regex.match(wkt) |
| return m.group('unit'), m.group('unit_name') |
| |
| @classmethod |
| def get_spheroid(cls, wkt, string=True): |
| """ |
| Class method used by GeometryField on initialization to |
| retrieve the `SPHEROID[..]` parameters from the given WKT. |
| """ |
| if gdal.HAS_GDAL: |
| srs = gdal.SpatialReference(wkt) |
| sphere_params = srs.ellipsoid |
| sphere_name = srs['spheroid'] |
| else: |
| m = cls.spheroid_regex.match(wkt) |
| if m: |
| sphere_params = (float(m.group('major')), float(m.group('flattening'))) |
| sphere_name = m.group('name') |
| else: |
| return None |
| |
| if not string: |
| return sphere_name, sphere_params |
| else: |
| # `string` parameter used to place in format acceptable by PostGIS |
| if len(sphere_params) == 3: |
| radius, flattening = sphere_params[0], sphere_params[2] |
| else: |
| radius, flattening = sphere_params |
| return 'SPHEROID["%s",%s,%s]' % (sphere_name, radius, flattening) |
| |
| def __unicode__(self): |
| """ |
| Returns the string representation. If GDAL is installed, |
| it will be 'pretty' OGC WKT. |
| """ |
| try: |
| return unicode(self.srs) |
| except: |
| return unicode(self.wkt) |
