| """ |
| The Spatial Reference class, represensents OGR Spatial Reference objects. |
| |
| Example: |
| >>> from django.contrib.gis.gdal import SpatialReference |
| >>> srs = SpatialReference('WGS84') |
| >>> print srs |
| GEOGCS["WGS 84", |
| DATUM["WGS_1984", |
| SPHEROID["WGS 84",6378137,298.257223563, |
| AUTHORITY["EPSG","7030"]], |
| TOWGS84[0,0,0,0,0,0,0], |
| AUTHORITY["EPSG","6326"]], |
| PRIMEM["Greenwich",0, |
| AUTHORITY["EPSG","8901"]], |
| UNIT["degree",0.01745329251994328, |
| AUTHORITY["EPSG","9122"]], |
| AUTHORITY["EPSG","4326"]] |
| >>> print srs.proj |
| +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs |
| >>> print srs.ellipsoid |
| (6378137.0, 6356752.3142451793, 298.25722356300003) |
| >>> print srs.projected, srs.geographic |
| False True |
| >>> srs.import_epsg(32140) |
| >>> print srs.name |
| NAD83 / Texas South Central |
| """ |
| import re |
| from types import UnicodeType, TupleType |
| from ctypes import byref, c_char_p, c_int, c_void_p |
| |
| # Getting the error checking routine and exceptions |
| from django.contrib.gis.gdal.error import OGRException, SRSException |
| from django.contrib.gis.gdal.prototypes.srs import * |
| |
| #### Spatial Reference class. #### |
| class SpatialReference(object): |
| """ |
| A wrapper for the OGRSpatialReference object. According to the GDAL website, |
| the SpatialReference object "provide[s] services to represent coordinate |
| systems (projections and datums) and to transform between them." |
| """ |
| |
| # Well-Known Geographical Coordinate System Name |
| _well_known = {'WGS84':4326, 'WGS72':4322, 'NAD27':4267, 'NAD83':4269} |
| _epsg_regex = re.compile('^(EPSG:)?(?P<epsg>\d+)$', re.I) |
| _proj_regex = re.compile(r'^\+proj') |
| |
| #### Python 'magic' routines #### |
| def __init__(self, srs_input='', srs_type='wkt'): |
| """ |
| Creates a GDAL OSR Spatial Reference object from the given input. |
| The input may be string of OGC Well Known Text (WKT), an integer |
| EPSG code, a PROJ.4 string, and/or a projection "well known" shorthand |
| string (one of 'WGS84', 'WGS72', 'NAD27', 'NAD83'). |
| """ |
| # Intializing pointer and string buffer. |
| self._ptr = None |
| buf = c_char_p('') |
| |
| if isinstance(srs_input, basestring): |
| # Encoding to ASCII if unicode passed in. |
| if isinstance(srs_input, UnicodeType): |
| srs_input = srs_input.encode('ascii') |
| |
| epsg_m = self._epsg_regex.match(srs_input) |
| proj_m = self._proj_regex.match(srs_input) |
| if epsg_m: |
| # Is this an EPSG well known name? |
| srs_type = 'epsg' |
| srs_input = int(epsg_m.group('epsg')) |
| elif proj_m: |
| # Is the string a PROJ.4 string? |
| srs_type = 'proj' |
| elif srs_input in self._well_known: |
| # Is this a short-hand well known name? |
| srs_type = 'epsg' |
| srs_input = self._well_known[srs_input] |
| elif srs_type == 'proj': |
| pass |
| else: |
| # Setting the buffer with WKT, PROJ.4 string, etc. |
| buf = c_char_p(srs_input) |
| elif isinstance(srs_input, int): |
| # EPSG integer code was input. |
| if srs_type != 'epsg': srs_type = 'epsg' |
| elif isinstance(srs_input, c_void_p): |
| srs_type = 'ogr' |
| else: |
| raise TypeError('Invalid SRS type "%s"' % srs_type) |
| |
| if srs_type == 'ogr': |
| # SRS input is OGR pointer |
| srs = srs_input |
| else: |
| # Creating a new pointer, using the string buffer. |
| srs = new_srs(buf) |
| |
| # If the pointer is NULL, throw an exception. |
| if not srs: |
| raise SRSException('Could not create spatial reference from: %s' % srs_input) |
| else: |
| self._ptr = srs |
| |
| # Post-processing if in PROJ.4 or EPSG formats. |
| if srs_type == 'proj': self.import_proj(srs_input) |
| elif srs_type == 'epsg': self.import_epsg(srs_input) |
| |
| def __del__(self): |
| "Destroys this spatial reference." |
| if self._ptr: release_srs(self._ptr) |
| |
| def __getitem__(self, target): |
| """ |
| Returns the value of the given string attribute node, None if the node |
| doesn't exist. Can also take a tuple as a parameter, (target, child), |
| where child is the index of the attribute in the WKT. For example: |
| |
| >>> wkt = 'GEOGCS["WGS 84", DATUM["WGS_1984, ... AUTHORITY["EPSG","4326"]]') |
| >>> srs = SpatialReference(wkt) # could also use 'WGS84', or 4326 |
| >>> print srs['GEOGCS'] |
| WGS 84 |
| >>> print srs['DATUM'] |
| WGS_1984 |
| >>> print srs['AUTHORITY'] |
| EPSG |
| >>> print srs['AUTHORITY', 1] # The authority value |
| 4326 |
| >>> print srs['TOWGS84', 4] # the fourth value in this wkt |
| 0 |
| >>> print srs['UNIT|AUTHORITY'] # For the units authority, have to use the pipe symbole. |
| EPSG |
| >>> print srs['UNIT|AUTHORITY', 1] # The authority value for the untis |
| 9122 |
| """ |
| if isinstance(target, TupleType): |
| return self.attr_value(*target) |
| else: |
| return self.attr_value(target) |
| |
| def __str__(self): |
| "The string representation uses 'pretty' WKT." |
| return self.pretty_wkt |
| |
| #### SpatialReference Methods #### |
| def attr_value(self, target, index=0): |
| """ |
| The attribute value for the given target node (e.g. 'PROJCS'). The index |
| keyword specifies an index of the child node to return. |
| """ |
| if not isinstance(target, str) or not isinstance(index, int): |
| raise TypeError |
| return get_attr_value(self._ptr, target, index) |
| |
| def auth_name(self, target): |
| "Returns the authority name for the given string target node." |
| return get_auth_name(self._ptr, target) |
| |
| def auth_code(self, target): |
| "Returns the authority code for the given string target node." |
| return get_auth_code(self._ptr, target) |
| |
| def clone(self): |
| "Returns a clone of this SpatialReference object." |
| return SpatialReference(clone_srs(self._ptr)) |
| |
| def from_esri(self): |
| "Morphs this SpatialReference from ESRI's format to EPSG." |
| morph_from_esri(self._ptr) |
| |
| def identify_epsg(self): |
| """ |
| This method inspects the WKT of this SpatialReference, and will |
| add EPSG authority nodes where an EPSG identifier is applicable. |
| """ |
| identify_epsg(self._ptr) |
| |
| def to_esri(self): |
| "Morphs this SpatialReference to ESRI's format." |
| morph_to_esri(self._ptr) |
| |
| def validate(self): |
| "Checks to see if the given spatial reference is valid." |
| srs_validate(self._ptr) |
| |
| #### Name & SRID properties #### |
| @property |
| def name(self): |
| "Returns the name of this Spatial Reference." |
| if self.projected: return self.attr_value('PROJCS') |
| elif self.geographic: return self.attr_value('GEOGCS') |
| elif self.local: return self.attr_value('LOCAL_CS') |
| else: return None |
| |
| @property |
| def srid(self): |
| "Returns the SRID of top-level authority, or None if undefined." |
| try: |
| return int(self.attr_value('AUTHORITY', 1)) |
| except (TypeError, ValueError): |
| return None |
| |
| #### Unit Properties #### |
| @property |
| def linear_name(self): |
| "Returns the name of the linear units." |
| units, name = linear_units(self._ptr, byref(c_char_p())) |
| return name |
| |
| @property |
| def linear_units(self): |
| "Returns the value of the linear units." |
| units, name = linear_units(self._ptr, byref(c_char_p())) |
| return units |
| |
| @property |
| def angular_name(self): |
| "Returns the name of the angular units." |
| units, name = angular_units(self._ptr, byref(c_char_p())) |
| return name |
| |
| @property |
| def angular_units(self): |
| "Returns the value of the angular units." |
| units, name = angular_units(self._ptr, byref(c_char_p())) |
| return units |
| |
| @property |
| def units(self): |
| """ |
| Returns a 2-tuple of the units value and the units name, |
| and will automatically determines whether to return the linear |
| or angular units. |
| """ |
| if self.projected or self.local: |
| return linear_units(self._ptr, byref(c_char_p())) |
| elif self.geographic: |
| return angular_units(self._ptr, byref(c_char_p())) |
| else: |
| return (None, None) |
| |
| #### Spheroid/Ellipsoid Properties #### |
| @property |
| def ellipsoid(self): |
| """ |
| Returns a tuple of the ellipsoid parameters: |
| (semimajor axis, semiminor axis, and inverse flattening) |
| """ |
| return (self.semi_major, self.semi_minor, self.inverse_flattening) |
| |
| @property |
| def semi_major(self): |
| "Returns the Semi Major Axis for this Spatial Reference." |
| return semi_major(self._ptr, byref(c_int())) |
| |
| @property |
| def semi_minor(self): |
| "Returns the Semi Minor Axis for this Spatial Reference." |
| return semi_minor(self._ptr, byref(c_int())) |
| |
| @property |
| def inverse_flattening(self): |
| "Returns the Inverse Flattening for this Spatial Reference." |
| return invflattening(self._ptr, byref(c_int())) |
| |
| #### Boolean Properties #### |
| @property |
| def geographic(self): |
| """ |
| Returns True if this SpatialReference is geographic |
| (root node is GEOGCS). |
| """ |
| return bool(isgeographic(self._ptr)) |
| |
| @property |
| def local(self): |
| "Returns True if this SpatialReference is local (root node is LOCAL_CS)." |
| return bool(islocal(self._ptr)) |
| |
| @property |
| def projected(self): |
| """ |
| Returns True if this SpatialReference is a projected coordinate system |
| (root node is PROJCS). |
| """ |
| return bool(isprojected(self._ptr)) |
| |
| #### Import Routines ##### |
| def import_wkt(self, wkt): |
| "Imports the Spatial Reference from OGC WKT (string)" |
| from_wkt(self._ptr, byref(c_char_p(wkt))) |
| |
| def import_proj(self, proj): |
| "Imports the Spatial Reference from a PROJ.4 string." |
| from_proj(self._ptr, proj) |
| |
| def import_epsg(self, epsg): |
| "Imports the Spatial Reference from the EPSG code (an integer)." |
| from_epsg(self._ptr, epsg) |
| |
| def import_xml(self, xml): |
| "Imports the Spatial Reference from an XML string." |
| from_xml(self._ptr, xml) |
| |
| #### Export Properties #### |
| @property |
| def wkt(self): |
| "Returns the WKT representation of this Spatial Reference." |
| return to_wkt(self._ptr, byref(c_char_p())) |
| |
| @property |
| def pretty_wkt(self, simplify=0): |
| "Returns the 'pretty' representation of the WKT." |
| return to_pretty_wkt(self._ptr, byref(c_char_p()), simplify) |
| |
| @property |
| def proj(self): |
| "Returns the PROJ.4 representation for this Spatial Reference." |
| return to_proj(self._ptr, byref(c_char_p())) |
| |
| @property |
| def proj4(self): |
| "Alias for proj()." |
| return self.proj |
| |
| @property |
| def xml(self, dialect=''): |
| "Returns the XML representation of this Spatial Reference." |
| # FIXME: This leaks memory, have to figure out why. |
| return to_xml(self._ptr, byref(c_char_p()), dialect) |
| |
| def to_esri(self): |
| "Morphs this SpatialReference to ESRI's format." |
| morph_to_esri(self._ptr) |
| |
| def from_esri(self): |
| "Morphs this SpatialReference from ESRI's format to EPSG." |
| morph_from_esri(self._ptr) |
| |
| class CoordTransform(object): |
| "The coordinate system transformation object." |
| |
| def __init__(self, source, target): |
| "Initializes on a source and target SpatialReference objects." |
| self._ptr = None # Initially NULL |
| if not isinstance(source, SpatialReference) or not isinstance(target, SpatialReference): |
| raise SRSException('source and target must be of type SpatialReference') |
| self._ptr = new_ct(source._ptr, target._ptr) |
| if not self._ptr: |
| raise SRSException('could not intialize CoordTransform object') |
| self._srs1_name = source.name |
| self._srs2_name = target.name |
| |
| def __del__(self): |
| "Deletes this Coordinate Transformation object." |
| if self._ptr: destroy_ct(self._ptr) |
| |
| def __str__(self): |
| return 'Transform from "%s" to "%s"' % (self._srs1_name, self._srs2_name) |
