+
−"""
+
− 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
+
−