| """ |
| Imports the SpatialRefSys and GeometryColumns models dependent on the |
| spatial database backend. |
| """ |
| import re |
| from django.conf import settings |
| |
| # Checking for the presence of GDAL (needed for the SpatialReference object) |
| from django.contrib.gis.gdal import HAS_GDAL, PYTHON23 |
| if HAS_GDAL: |
| from django.contrib.gis.gdal import SpatialReference |
| |
| 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+)"\])?\]$') |
| |
| def srs(self): |
| """ |
| Returns a GDAL SpatialReference object, if GDAL is installed. |
| """ |
| if HAS_GDAL: |
| 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 = SpatialReference(self.wkt) |
| 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.') |
| srs = property(srs) |
| |
| def ellipsoid(self): |
| """ |
| Returns a tuple of the ellipsoid parameters: |
| (semimajor axis, semiminor axis, and inverse flattening). |
| """ |
| if 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 |
| ellipsoid = property(ellipsoid) |
| |
| def name(self): |
| "Returns the projection name." |
| return self.srs.name |
| name = property(name) |
| |
| def spheroid(self): |
| "Returns the spheroid name for this spatial reference." |
| return self.srs['spheroid'] |
| spheroid = property(spheroid) |
| |
| def datum(self): |
| "Returns the datum for this spatial reference." |
| return self.srs['datum'] |
| datum = property(datum) |
| |
| def projected(self): |
| "Is this Spatial Reference projected?" |
| if HAS_GDAL: |
| return self.srs.projected |
| else: |
| return self.wkt.startswith('PROJCS') |
| projected = property(projected) |
| |
| def local(self): |
| "Is this Spatial Reference local?" |
| if HAS_GDAL: |
| return self.srs.local |
| else: |
| return self.wkt.startswith('LOCAL_CS') |
| local = property(local) |
| |
| def geographic(self): |
| "Is this Spatial Reference geographic?" |
| if HAS_GDAL: |
| return self.srs.geographic |
| else: |
| return self.wkt.startswith('GEOGCS') |
| geographic = property(geographic) |
| |
| def linear_name(self): |
| "Returns the linear units name." |
| if 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') |
| linear_name = property(linear_name) |
| |
| def linear_units(self): |
| "Returns the linear units." |
| if HAS_GDAL: |
| return self.srs.linear_units |
| elif self.geographic: |
| return None |
| else: |
| m = self.units_regex.match(self.wkt) |
| return m.group('unit') |
| linear_units = property(linear_units) |
| |
| def angular_name(self): |
| "Returns the name of the angular units." |
| if 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') |
| angular_name = property(angular_name) |
| |
| def angular_units(self): |
| "Returns the angular units." |
| if HAS_GDAL: |
| return self.srs.angular_units |
| elif self.projected: |
| return None |
| else: |
| m = self.units_regex.match(self.wkt) |
| return m.group('unit') |
| angular_units = property(angular_units) |
| |
| 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) |
| units = property(units) |
| |
| 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 HAS_GDAL: |
| return SpatialReference(wkt).units |
| else: |
| m = cls.units_regex.match(wkt) |
| return m.group('unit'), m.group('unit_name') |
| get_units = classmethod(get_units) |
| |
| def get_spheroid(cls, wkt, string=True): |
| """ |
| Class method used by GeometryField on initialization to |
| retrieve the `SPHEROID[..]` parameters from the given WKT. |
| """ |
| if HAS_GDAL: |
| srs = 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) |
| get_spheroid = classmethod(get_spheroid) |
| |
| 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) |
| |
| # The SpatialRefSys and GeometryColumns models |
| _srid_info = True |
| if not PYTHON23 and settings.DATABASE_ENGINE == 'postgresql_psycopg2': |
| # Because the PostGIS version is checked when initializing the spatial |
| # backend a `ProgrammingError` will be raised if the PostGIS tables |
| # and functions are not installed. We catch here so it won't be raised when |
| # running the Django test suite. `ImportError` is also possible if no ctypes. |
| try: |
| from django.contrib.gis.db.backend.postgis.models import GeometryColumns, SpatialRefSys |
| except: |
| _srid_info = False |
| elif not PYTHON23 and settings.DATABASE_ENGINE == 'oracle': |
| # Same thing as above, except the GEOS library is attempted to be loaded for |
| # `BaseSpatialBackend`, and an exception will be raised during the |
| # Django test suite if it doesn't exist. |
| try: |
| from django.contrib.gis.db.backend.oracle.models import GeometryColumns, SpatialRefSys |
| except: |
| _srid_info = False |
| else: |
| _srid_info = False |
| |
| if _srid_info: |
| def get_srid_info(srid): |
| """ |
| Returns the units, unit name, and spheroid WKT associated with the |
| given SRID from the `spatial_ref_sys` (or equivalent) spatial database |
| table. We use a database cursor to execute the query because this |
| function is used when it is not possible to use the ORM (for example, |
| during field initialization). |
| """ |
| # SRID=-1 is a common convention for indicating the geometry has no |
| # spatial reference information associated with it. Thus, we will |
| # return all None values without raising an exception. |
| if srid == -1: return None, None, None |
| |
| # Getting the spatial reference WKT associated with the SRID from the |
| # `spatial_ref_sys` (or equivalent) spatial database table. This query |
| # cannot be executed using the ORM because this information is needed |
| # when the ORM cannot be used (e.g., during the initialization of |
| # `GeometryField`). |
| from django.db import connection |
| cur = connection.cursor() |
| qn = connection.ops.quote_name |
| stmt = 'SELECT %(table)s.%(wkt_col)s FROM %(table)s WHERE (%(table)s.%(srid_col)s = %(srid)s)' |
| stmt = stmt % {'table' : qn(SpatialRefSys._meta.db_table), |
| 'wkt_col' : qn(SpatialRefSys.wkt_col()), |
| 'srid_col' : qn('srid'), |
| 'srid' : srid, |
| } |
| cur.execute(stmt) |
| |
| # Fetching the WKT from the cursor; if the query failed raise an Exception. |
| fetched = cur.fetchone() |
| if not fetched: |
| raise ValueError('Failed to find spatial reference entry in "%s" corresponding to SRID=%s.' % |
| (SpatialRefSys._meta.db_table, srid)) |
| srs_wkt = fetched[0] |
| |
| # Getting metadata associated with the spatial reference system identifier. |
| # Specifically, getting the unit information and spheroid information |
| # (both required for distance queries). |
| unit, unit_name = SpatialRefSys.get_units(srs_wkt) |
| spheroid = SpatialRefSys.get_spheroid(srs_wkt) |
| return unit, unit_name, spheroid |
| else: |
| def get_srid_info(srid): |
| """ |
| Dummy routine for the backends that do not have the OGC required |
| spatial metadata tables (like MySQL). |
| """ |
| return None, None, None |
| |
