def proj4_str_to_dict(proj4_str): """Convert PROJ.4 compatible string definition to dict EPSG codes should be provided as "EPSG:XXXX" where "XXXX" is the EPSG number code. It can also be provided as ``"+init=EPSG:XXXX"`` as long as the underlying PROJ library supports it (deprecated in PROJ 6.0+). Note: Key only parameters will be assigned a value of `True`. """ # convert EPSG codes to equivalent PROJ4 string definition if proj4_str.startswith('EPSG:') and CRS is not None: crs = CRS(proj4_str) if hasattr(crs, 'to_dict'): # pyproj 2.2+ return crs.to_dict() proj4_str = crs.to_proj4() elif proj4_str.startswith('EPSG:'): # legacy +init= PROJ4 string and no pyproj 2.0+ to help convert proj4_str = "+init={}".format(proj4_str) pairs = (x.split('=', 1) for x in proj4_str.replace('+', '').split(" ")) return convert_proj_floats(pairs)
class Proj(_proj.Proj): """ Performs cartographic transformations (converts from longitude,latitude to native map projection x,y coordinates and vice versa) using proj (https://proj.org). A Proj class instance is initialized with proj map projection control parameter key/value pairs. The key/value pairs can either be passed in a dictionary, or as keyword arguments, or as a PROJ string (compatible with the proj command). See https://proj.org/operations/projections/index.html for examples of key/value pairs defining different map projections. Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). If optional keyword 'inverse' is True (default is False), the inverse transformation from x/y to lon/lat is performed. If optional keyword 'errcheck' is True (default is False) an exception is raised if the transformation is invalid. If errcheck=False and the transformation is invalid, no exception is raised and 1.e30 is returned. If the optional keyword 'preserve_units' is True, the units in map projection coordinates are not forced to be meters. Works with numpy and regular python array objects, python sequences and scalars. Attributes ---------- srs: str The string form of the user input used to create the Proj. crs: ~pyproj.crs.CRS The CRS object associated with the Proj. proj_version: int The major version number for PROJ. """ def __init__(self, projparams=None, preserve_units=True, **kwargs): """ initialize a Proj class instance. See the PROJ documentation (https://proj.org) for more information about projection parameters. Parameters ---------- projparams: int, str, dict, pyproj.CRS A PROJ or WKT string, PROJ dict, EPSG integer, or a pyproj.CRS instnace. preserve_units: bool If false, will ensure +units=m. **kwargs: PROJ projection parameters. Example usage: >>> from pyproj import Proj >>> p = Proj(proj='utm',zone=10,ellps='WGS84', preserve_units=False) >>> x,y = p(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> 'lon=%8.3f lat=%5.3f' % p(x,y,inverse=True) 'lon=-120.108 lat=34.361' >>> # do 3 cities at a time in a tuple (Fresno, LA, SF) >>> lons = (-119.72,-118.40,-122.38) >>> lats = (36.77, 33.93, 37.62 ) >>> x,y = p(lons, lats) >>> 'x: %9.3f %9.3f %9.3f' % x 'x: 792763.863 925321.537 554714.301' >>> 'y: %9.3f %9.3f %9.3f' % y 'y: 4074377.617 3763936.941 4163835.303' >>> lons, lats = p(x, y, inverse=True) # inverse transform >>> 'lons: %8.3f %8.3f %8.3f' % lons 'lons: -119.720 -118.400 -122.380' >>> 'lats: %8.3f %8.3f %8.3f' % lats 'lats: 36.770 33.930 37.620' >>> p2 = Proj('+proj=utm +zone=10 +ellps=WGS84', preserve_units=False) >>> x,y = p2(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> p = Proj(init="epsg:32667", preserve_units=False) >>> 'x=%12.3f y=%12.3f (meters)' % p(-114.057222, 51.045) 'x=-1783506.250 y= 6193827.033 (meters)' >>> p = Proj("+init=epsg:32667") >>> 'x=%12.3f y=%12.3f (feet)' % p(-114.057222, 51.045) 'x=-5851386.754 y=20320914.191 (feet)' >>> # test data with radian inputs >>> p1 = Proj(init="epsg:4214") >>> x1, y1 = p1(116.366, 39.867) >>> '{:.3f} {:.3f}'.format(x1, y1) '2.031 0.696' >>> x2, y2 = p1(x1, y1, inverse=True) >>> '{:.3f} {:.3f}'.format(x2, y2) '116.366 39.867' """ self.crs = CRS.from_user_input( projparams if projparams is not None else kwargs) # make sure units are meters if preserve_units is False. if not preserve_units and "foot" in self.crs.axis_info[0].unit_name: projstring = self.crs.to_proj4(4) projstring = re.sub(r"\s\+units=[\w-]+", "", projstring) projstring += " +units=m" self.crs = CRS(projstring) projstring = self.crs.to_proj4() or self.crs.srs projstring = re.sub(r"\s\+?type=crs", "", projstring) super(Proj, self).__init__(cstrencode(projstring.strip())) def __call__(self, *args, **kw): # ,lon,lat,inverse=False,errcheck=False): """ Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). If optional keyword 'inverse' is True (default is False), the inverse transformation from x/y to lon/lat is performed. If optional keyword 'errcheck' is True (default is False) an exception is raised if the transformation is invalid. If errcheck=False and the transformation is invalid, no exception is raised and 1.e30 is returned. Inputs should be doubles (they will be cast to doubles if they are not, causing a slight performance hit). Works with numpy and regular python array objects, python sequences and scalars, but is fastest for array objects. """ inverse = kw.get("inverse", False) errcheck = kw.get("errcheck", False) lon, lat = args # process inputs, making copies that support buffer API. inx, xisfloat, xislist, xistuple = _copytobuffer(lon) iny, yisfloat, yislist, yistuple = _copytobuffer(lat) # call PROJ functions. inx and iny modified in place. if inverse: self._inv(inx, iny, errcheck=errcheck) else: self._fwd(inx, iny, errcheck=errcheck) # if inputs were lists, tuples or floats, convert back. outx = _convertback(xisfloat, xislist, xistuple, inx) outy = _convertback(yisfloat, yislist, xistuple, iny) return outx, outy def definition_string(self): """Returns formal definition string for projection >>> Proj('+init=epsg:4326').definition_string() 'proj=longlat datum=WGS84 no_defs ellps=WGS84 towgs84=0,0,0' >>> """ return pystrdecode(self.definition) def to_latlong_def(self): """return the definition string of the geographic (lat/lon) coordinate version of the current projection""" return self.crs.geodetic_crs.to_proj4(4) def to_latlong(self): """return a new Proj instance which is the geographic (lat/lon) coordinate version of the current projection""" return Proj(self.crs.geodetic_crs)
class Proj(_proj.Proj): """ performs cartographic transformations (converts from longitude,latitude to native map projection x,y coordinates and vice versa) using proj (https://github.com/OSGeo/proj.4/wiki). A Proj class instance is initialized with proj map projection control parameter key/value pairs. The key/value pairs can either be passed in a dictionary, or as keyword arguments, or as a proj4 string (compatible with the proj command). See http://www.remotesensing.org/geotiff/proj_list for examples of key/value pairs defining different map projections. Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). If optional keyword 'inverse' is True (default is False), the inverse transformation from x/y to lon/lat is performed. If optional keyword 'errcheck' is True (default is False) an exception is raised if the transformation is invalid. If errcheck=False and the transformation is invalid, no exception is raised and 1.e30 is returned. If the optional keyword 'preserve_units' is True, the units in map projection coordinates are not forced to be meters. Works with numpy and regular python array objects, python sequences and scalars. """ def __init__(self, projparams=None, preserve_units=True, **kwargs): """ initialize a Proj class instance. See the proj documentation (https://github.com/OSGeo/proj.4/wiki) for more information about projection parameters. Parameters ---------- projparams: int, str, dict, pyproj.CRS A proj.4 or WKT string, proj.4 dict, EPSG integer, or a pyproj.CRS instnace. preserve_units: bool If false, will ensure +units=m. **kwargs: proj.4 projection parameters. Example usage: >>> from pyproj import Proj >>> p = Proj(proj='utm',zone=10,ellps='WGS84', preserve_units=False) # use kwargs >>> x,y = p(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> 'lon=%8.3f lat=%5.3f' % p(x,y,inverse=True) 'lon=-120.108 lat=34.361' >>> # do 3 cities at a time in a tuple (Fresno, LA, SF) >>> lons = (-119.72,-118.40,-122.38) >>> lats = (36.77, 33.93, 37.62 ) >>> x,y = p(lons, lats) >>> 'x: %9.3f %9.3f %9.3f' % x 'x: 792763.863 925321.537 554714.301' >>> 'y: %9.3f %9.3f %9.3f' % y 'y: 4074377.617 3763936.941 4163835.303' >>> lons, lats = p(x, y, inverse=True) # inverse transform >>> 'lons: %8.3f %8.3f %8.3f' % lons 'lons: -119.720 -118.400 -122.380' >>> 'lats: %8.3f %8.3f %8.3f' % lats 'lats: 36.770 33.930 37.620' >>> p2 = Proj('+proj=utm +zone=10 +ellps=WGS84', preserve_units=False) # use proj4 string >>> x,y = p2(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> p = Proj(init="epsg:32667", preserve_units=False) >>> 'x=%12.3f y=%12.3f (meters)' % p(-114.057222, 51.045) 'x=-1783506.250 y= 6193827.033 (meters)' >>> p = Proj("+init=epsg:32667") >>> 'x=%12.3f y=%12.3f (feet)' % p(-114.057222, 51.045) 'x=-5851386.754 y=20320914.191 (feet)' >>> # test data with radian inputs >>> p1 = Proj(init="epsg:4214") >>> x1, y1 = p1(116.366, 39.867) >>> '{:.3f} {:.3f}'.format(x1, y1) '2.031 0.696' >>> x2, y2 = p1(x1, y1, inverse=True) >>> '{:.3f} {:.3f}'.format(x2, y2) '116.366 39.867' """ self.crs = CRS.from_user_input(projparams if projparams is not None else kwargs) # make sure units are meters if preserve_units is False. if not preserve_units and "foot" in self.crs.axis_info[0].unit_name: projstring = self.crs.to_proj4(4) projstring = re.sub(r"\s\+units=[\w-]+", "", projstring) projstring += " +units=m" self.crs = CRS(projstring) super(Proj, self).__init__( cstrencode(self.crs.to_proj4().replace("+type=crs", "").strip()) ) def __call__(self, *args, **kw): # ,lon,lat,inverse=False,errcheck=False): """ Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). If optional keyword 'inverse' is True (default is False), the inverse transformation from x/y to lon/lat is performed. If optional keyword 'errcheck' is True (default is False) an exception is raised if the transformation is invalid. If errcheck=False and the transformation is invalid, no exception is raised and 1.e30 is returned. Inputs should be doubles (they will be cast to doubles if they are not, causing a slight performance hit). Works with numpy and regular python array objects, python sequences and scalars, but is fastest for array objects. """ inverse = kw.get("inverse", False) errcheck = kw.get("errcheck", False) # if len(args) == 1: # latlon = np.array(args[0], copy=True, # order='C', dtype=float, ndmin=2) # if inverse: # _proj.Proj._invn(self, latlon, radians=radians, errcheck=errcheck) # else: # _proj.Proj._fwdn(self, latlon, radians=radians, errcheck=errcheck) # return latlon lon, lat = args # process inputs, making copies that support buffer API. inx, xisfloat, xislist, xistuple = _copytobuffer(lon) iny, yisfloat, yislist, yistuple = _copytobuffer(lat) # call proj4 functions. inx and iny modified in place. if inverse: self._inv(inx, iny, errcheck=errcheck) else: self._fwd(inx, iny, errcheck=errcheck) # if inputs were lists, tuples or floats, convert back. outx = _convertback(xisfloat, xislist, xistuple, inx) outy = _convertback(yisfloat, yislist, xistuple, iny) return outx, outy def is_latlong(self): """ Returns ------- bool: True if projection in geographic (lon/lat) coordinates. """ warnings.warn("'is_latlong()' is deprecated. Please use 'crs.is_geographic'.") return self.crs.is_geographic def is_geocent(self): """ Returns ------- bool: True if projection in geocentric (x/y) coordinates """ warnings.warn("'is_geocent()' is deprecated. Please use 'crs.is_geocent'.") return self.is_geocent def definition_string(self): """Returns formal definition string for projection >>> Proj('+init=epsg:4326').definition_string() 'proj=longlat datum=WGS84 no_defs ellps=WGS84 towgs84=0,0,0' >>> """ return pystrdecode(self.definition) def to_latlong_def(self): """return the definition string of the geographic (lat/lon) coordinate version of the current projection""" # This is a little hacky way of getting a latlong proj object # Maybe instead of this function the __cinit__ function can take a # Proj object and a type (where type = "geographic") as the libproj # java wrapper return self.crs.to_geodetic().to_proj4(4) # deprecated : using in transform raised a TypeError in release 1.9.5.1 # reported in issue #53, resolved in #73. def to_latlong(self): """return a new Proj instance which is the geographic (lat/lon) coordinate version of the current projection""" return Proj(self.crs.to_geodetic())
class Proj(_Proj): """ Performs cartographic transformations (converts from longitude,latitude to native map projection x,y coordinates and vice versa) using proj (https://proj.org). A Proj class instance is initialized with proj map projection control parameter key/value pairs. The key/value pairs can either be passed in a dictionary, or as keyword arguments, or as a PROJ string (compatible with the proj command). See https://proj.org/operations/projections/index.html for examples of key/value pairs defining different map projections. Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). If optional keyword 'inverse' is True (default is False), the inverse transformation from x/y to lon/lat is performed. If optional keyword 'errcheck' is True (default is False) an exception is raised if the transformation is invalid. If errcheck=False and the transformation is invalid, no exception is raised and 'inf' is returned. If the optional keyword 'preserve_units' is True, the units in map projection coordinates are not forced to be meters. Works with numpy and regular python array objects, python sequences and scalars. Attributes ---------- srs: str The string form of the user input used to create the Proj. crs: pyproj.crs.CRS The CRS object associated with the Proj. """ def __init__(self, projparams=None, preserve_units=True, **kwargs): """ initialize a Proj class instance. See the PROJ documentation (https://proj.org) for more information about projection parameters. Parameters ---------- projparams: int, str, dict, pyproj.CRS A PROJ or WKT string, PROJ dict, EPSG integer, or a pyproj.CRS instnace. preserve_units: bool If false, will ensure +units=m. **kwargs: PROJ projection parameters. Example usage: >>> from pyproj import Proj >>> p = Proj(proj='utm',zone=10,ellps='WGS84', preserve_units=False) >>> x,y = p(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> 'lon=%8.3f lat=%5.3f' % p(x,y,inverse=True) 'lon=-120.108 lat=34.361' >>> # do 3 cities at a time in a tuple (Fresno, LA, SF) >>> lons = (-119.72,-118.40,-122.38) >>> lats = (36.77, 33.93, 37.62 ) >>> x,y = p(lons, lats) >>> 'x: %9.3f %9.3f %9.3f' % x 'x: 792763.863 925321.537 554714.301' >>> 'y: %9.3f %9.3f %9.3f' % y 'y: 4074377.617 3763936.941 4163835.303' >>> lons, lats = p(x, y, inverse=True) # inverse transform >>> 'lons: %8.3f %8.3f %8.3f' % lons 'lons: -119.720 -118.400 -122.380' >>> 'lats: %8.3f %8.3f %8.3f' % lats 'lats: 36.770 33.930 37.620' >>> p2 = Proj('+proj=utm +zone=10 +ellps=WGS84', preserve_units=False) >>> x,y = p2(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> p = Proj("epsg:32667", preserve_units=False) >>> 'x=%12.3f y=%12.3f (meters)' % p(-114.057222, 51.045) 'x=-1783506.250 y= 6193827.033 (meters)' >>> p = Proj("epsg:32667") >>> 'x=%12.3f y=%12.3f (feet)' % p(-114.057222, 51.045) 'x=-5851386.754 y=20320914.191 (feet)' >>> # test data with radian inputs >>> p1 = Proj("epsg:4214") >>> x1, y1 = p1(116.366, 39.867) >>> '{:.3f} {:.3f}'.format(x1, y1) '116.366 39.867' >>> x2, y2 = p1(x1, y1, inverse=True) >>> '{:.3f} {:.3f}'.format(x2, y2) '116.366 39.867' """ self.crs = CRS.from_user_input(projparams if projparams is not None else kwargs) # make sure units are meters if preserve_units is False. if not preserve_units and "foot" in self.crs.axis_info[0].unit_name: # ignore export to PROJ string deprecation warning with warnings.catch_warnings(): warnings.filterwarnings( "ignore", "You will likely lose important projection information", UserWarning, ) projstring = self.crs.to_proj4(4) projstring = re.sub(r"\s\+units=[\w-]+", "", projstring) projstring += " +units=m" self.crs = CRS(projstring) # ignore export to PROJ string deprecation warning with warnings.catch_warnings(): warnings.filterwarnings( "ignore", "You will likely lose important projection information", UserWarning, ) projstring = self.crs.to_proj4() or self.crs.srs projstring = re.sub(r"\s\+?type=crs", "", projstring) super().__init__(cstrencode(projstring.strip())) def __call__(self, *args, **kw): # ,lon,lat,inverse=False,errcheck=False): """ Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). If optional keyword 'inverse' is True (default is False), the inverse transformation from x/y to lon/lat is performed. If optional keyword 'errcheck' is True (default is False) an exception is raised if the transformation is invalid. If errcheck=False and the transformation is invalid, no exception is raised and 'inf' is returned. Inputs should be doubles (they will be cast to doubles if they are not, causing a slight performance hit). Works with numpy and regular python array objects, python sequences and scalars, but is fastest for array objects. """ inverse = kw.get("inverse", False) errcheck = kw.get("errcheck", False) lon, lat = args # process inputs, making copies that support buffer API. inx, xisfloat, xislist, xistuple = _copytobuffer(lon) iny, yisfloat, yislist, yistuple = _copytobuffer(lat) # call PROJ functions. inx and iny modified in place. if inverse: self._inv(inx, iny, errcheck=errcheck) else: self._fwd(inx, iny, errcheck=errcheck) # if inputs were lists, tuples or floats, convert back. outx = _convertback(xisfloat, xislist, xistuple, inx) outy = _convertback(yisfloat, yislist, xistuple, iny) return outx, outy def get_factors( self, longitude, latitude, radians=False, errcheck=False, ): """ .. versionadded:: 2.6.0 Calculate various cartographic properties, such as scale factors, angular distortion and meridian convergence. Depending on the underlying projection values will be calculated either numerically (default) or analytically. The function also calculates the partial derivatives of the given coordinate. Parameters ---------- longitude: scalar or array (numpy or python) Input longitude coordinate(s). latitude: scalar or array (numpy or python) Input latitude coordinate(s). radians: boolean, optional If True, will expect input data to be in radians. Default is False (degrees). errcheck: boolean, optional (default False) If True an exception is raised if the errors are found in the process. By default errcheck=False and ``inf`` is returned. Returns ------- Factors """ # process inputs, making copies that support buffer API. inx, xisfloat, xislist, xistuple = _copytobuffer(longitude) iny, yisfloat, yislist, yistuple = _copytobuffer(latitude) # calculate the factors factors = self._get_factors(inx, iny, radians=radians, errcheck=errcheck) # if inputs were lists, tuples or floats, convert back. return Factors( meridional_scale=_convertback( xisfloat, xislist, xistuple, factors.meridional_scale ), parallel_scale=_convertback( xisfloat, xislist, xistuple, factors.parallel_scale ), areal_scale=_convertback(xisfloat, xislist, xistuple, factors.areal_scale), angular_distortion=_convertback( xisfloat, xislist, xistuple, factors.angular_distortion ), meridian_parallel_angle=_convertback( xisfloat, xislist, xistuple, factors.meridian_parallel_angle ), meridian_convergence=_convertback( xisfloat, xislist, xistuple, factors.meridian_convergence ), tissot_semimajor=_convertback( xisfloat, xislist, xistuple, factors.tissot_semimajor ), tissot_semiminor=_convertback( xisfloat, xislist, xistuple, factors.tissot_semiminor ), dx_dlam=_convertback(xisfloat, xislist, xistuple, factors.dx_dlam), dx_dphi=_convertback(xisfloat, xislist, xistuple, factors.dx_dphi), dy_dlam=_convertback(xisfloat, xislist, xistuple, factors.dy_dlam), dy_dphi=_convertback(xisfloat, xislist, xistuple, factors.dy_dphi), ) def definition_string(self): """Returns formal definition string for projection >>> Proj("epsg:4326").definition_string() 'proj=longlat datum=WGS84 no_defs ellps=WGS84 towgs84=0,0,0' >>> """ return pystrdecode(self.definition) def to_latlong_def(self): """return the definition string of the geographic (lat/lon) coordinate version of the current projection""" return self.crs.geodetic_crs.to_proj4(4) def to_latlong(self): """return a new Proj instance which is the geographic (lat/lon) coordinate version of the current projection""" return Proj(self.crs.geodetic_crs) def __reduce__(self): """special method that allows pyproj.Proj instance to be pickled""" return self.__class__, (self.crs.srs,) def __repr__(self): return "Proj('{srs}', preserve_units=True)".format(srs=self.srs) def __eq__(self, other): if not isinstance(other, Proj): return False return self._is_equivalent(other)
class Proj(Transformer): """ Performs cartographic transformations. Converts from longitude, latitude to native map projection x,y coordinates and vice versa using PROJ (https://proj.org). Attributes ---------- srs: str The string form of the user input used to create the Proj. crs: pyproj.crs.CRS The CRS object associated with the Proj. """ def __init__( self, projparams: Any = None, preserve_units: bool = True, network=None, **kwargs, ) -> None: """ A Proj class instance is initialized with proj map projection control parameter key/value pairs. The key/value pairs can either be passed in a dictionary, or as keyword arguments, or as a PROJ string (compatible with the proj command). See https://proj.org/operations/projections/index.html for examples of key/value pairs defining different map projections. .. versionadded:: 3.0.0 network Parameters ---------- projparams: int, str, dict, pyproj.CRS A PROJ or WKT string, PROJ dict, EPSG integer, or a pyproj.CRS instance. preserve_units: bool If false, will ensure +units=m. network: bool, optional Default is None, which uses the system defaults for networking. If True, it will force the use of network for grids regardless of any other network setting. If False, it will force disable use of network for grids regardless of any other network setting. **kwargs: PROJ projection parameters. Example usage: >>> from pyproj import Proj >>> p = Proj(proj='utm',zone=10,ellps='WGS84', preserve_units=False) >>> x,y = p(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> 'lon=%8.3f lat=%5.3f' % p(x,y,inverse=True) 'lon=-120.108 lat=34.361' >>> # do 3 cities at a time in a tuple (Fresno, LA, SF) >>> lons = (-119.72,-118.40,-122.38) >>> lats = (36.77, 33.93, 37.62 ) >>> x,y = p(lons, lats) >>> 'x: %9.3f %9.3f %9.3f' % x 'x: 792763.863 925321.537 554714.301' >>> 'y: %9.3f %9.3f %9.3f' % y 'y: 4074377.617 3763936.941 4163835.303' >>> lons, lats = p(x, y, inverse=True) # inverse transform >>> 'lons: %8.3f %8.3f %8.3f' % lons 'lons: -119.720 -118.400 -122.380' >>> 'lats: %8.3f %8.3f %8.3f' % lats 'lats: 36.770 33.930 37.620' >>> p2 = Proj('+proj=utm +zone=10 +ellps=WGS84', preserve_units=False) >>> x,y = p2(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> p = Proj("epsg:32667", preserve_units=False) >>> 'x=%12.3f y=%12.3f (meters)' % p(-114.057222, 51.045) 'x=-1783506.250 y= 6193827.033 (meters)' >>> p = Proj("epsg:32667") >>> 'x=%12.3f y=%12.3f (feet)' % p(-114.057222, 51.045) 'x=-5851386.754 y=20320914.191 (feet)' >>> # test data with radian inputs >>> p1 = Proj("epsg:4214") >>> x1, y1 = p1(116.366, 39.867) >>> f'{x1:.3f} {y1:.3f}' '116.366 39.867' >>> x2, y2 = p1(x1, y1, inverse=True) >>> f'{x2:.3f} {y2:.3f}' '116.366 39.867' """ self.crs = CRS.from_user_input(projparams, **kwargs) # make sure units are meters if preserve_units is False. if not preserve_units and "foot" in self.crs.axis_info[0].unit_name: # ignore export to PROJ string deprecation warning with warnings.catch_warnings(): warnings.filterwarnings( "ignore", "You will likely lose important projection information", UserWarning, ) projstring = self.crs.to_proj4(4) projstring = re.sub(r"\s\+units=[\w-]+", "", projstring) projstring += " +units=m" self.crs = CRS(projstring) # ignore export to PROJ string deprecation warning with warnings.catch_warnings(): warnings.filterwarnings( "ignore", "You will likely lose important projection information", UserWarning, ) projstring = self.crs.to_proj4() or self.crs.srs self.srs = re.sub(r"\s\+?type=crs", "", projstring).strip() super().__init__( _Transformer.from_pipeline(cstrencode(self.srs), network=network) ) def __call__( self, longitude: Any, latitude: Any, inverse: bool = False, errcheck: bool = False, radians: bool = False, ) -> Tuple[Any, Any]: """ Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). Inputs should be doubles (they will be cast to doubles if they are not, causing a slight performance hit). Works with numpy and regular python array objects, python sequences and scalars, but is fastest for array objects. Parameters ---------- longitude: scalar or array (numpy or python) Input longitude coordinate(s). latitude: scalar or array (numpy or python) Input latitude coordinate(s). inverse: boolean, optional If inverse is True the inverse transformation from x/y to lon/lat is performed. Default is False. radians: boolean, optional If True, will expect input data to be in radians and will return radians if the projection is geographic. Default is False (degrees). This does not work with pyproj 2 and is ignored. It will be enabled again in pyproj 3. errcheck: boolean, optional If True an exception is raised if the errors are found in the process. By default errcheck=False and ``inf`` is returned. Returns ------- Tuple[Any, Any]: The transformed coordinates. """ if inverse: direction = TransformDirection.INVERSE else: direction = TransformDirection.FORWARD return self.transform( xx=longitude, yy=latitude, direction=direction, errcheck=errcheck, radians=radians, ) def get_factors( self, longitude: Any, latitude: Any, radians: bool = False, errcheck: bool = False, ) -> Factors: """ .. versionadded:: 2.6.0 Calculate various cartographic properties, such as scale factors, angular distortion and meridian convergence. Depending on the underlying projection values will be calculated either numerically (default) or analytically. The function also calculates the partial derivatives of the given coordinate. Parameters ---------- longitude: scalar or array (numpy or python) Input longitude coordinate(s). latitude: scalar or array (numpy or python) Input latitude coordinate(s). radians: boolean, optional If True, will expect input data to be in radians. Default is False (degrees). errcheck: boolean, optional If True an exception is raised if the errors are found in the process. By default errcheck=False and ``inf`` is returned. Returns ------- Factors """ # process inputs, making copies that support buffer API. inx, xisfloat, xislist, xistuple = _copytobuffer(longitude) iny, yisfloat, yislist, yistuple = _copytobuffer(latitude) # calculate the factors factors = self._transformer._get_factors( inx, iny, radians=radians, errcheck=errcheck ) # if inputs were lists, tuples or floats, convert back. return Factors( meridional_scale=_convertback( xisfloat, xislist, xistuple, factors.meridional_scale ), parallel_scale=_convertback( xisfloat, xislist, xistuple, factors.parallel_scale ), areal_scale=_convertback(xisfloat, xislist, xistuple, factors.areal_scale), angular_distortion=_convertback( xisfloat, xislist, xistuple, factors.angular_distortion ), meridian_parallel_angle=_convertback( xisfloat, xislist, xistuple, factors.meridian_parallel_angle ), meridian_convergence=_convertback( xisfloat, xislist, xistuple, factors.meridian_convergence ), tissot_semimajor=_convertback( xisfloat, xislist, xistuple, factors.tissot_semimajor ), tissot_semiminor=_convertback( xisfloat, xislist, xistuple, factors.tissot_semiminor ), dx_dlam=_convertback(xisfloat, xislist, xistuple, factors.dx_dlam), dx_dphi=_convertback(xisfloat, xislist, xistuple, factors.dx_dphi), dy_dlam=_convertback(xisfloat, xislist, xistuple, factors.dy_dlam), dy_dphi=_convertback(xisfloat, xislist, xistuple, factors.dy_dphi), ) def definition_string(self) -> str: """Returns formal definition string for projection >>> Proj("epsg:4326").definition_string() 'proj=longlat datum=WGS84 no_defs ellps=WGS84 towgs84=0,0,0' """ return pystrdecode(self.definition) def to_latlong_def(self) -> Optional[str]: """return the definition string of the geographic (lat/lon) coordinate version of the current projection""" return self.crs.geodetic_crs.to_proj4(4) if self.crs.geodetic_crs else None def to_latlong(self) -> "Proj": """return a new Proj instance which is the geographic (lat/lon) coordinate version of the current projection""" return Proj(self.crs.geodetic_crs) def __reduce__(self) -> Tuple[Type["Proj"], Tuple[str]]: """special method that allows pyproj.Proj instance to be pickled""" return self.__class__, (self.crs.srs,)
class Proj(_proj.Proj): """ performs cartographic transformations (converts from longitude,latitude to native map projection x,y coordinates and vice versa) using proj (https://github.com/OSGeo/proj.4/wiki). A Proj class instance is initialized with proj map projection control parameter key/value pairs. The key/value pairs can either be passed in a dictionary, or as keyword arguments, or as a proj4 string (compatible with the proj command). See http://www.remotesensing.org/geotiff/proj_list for examples of key/value pairs defining different map projections. Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). If optional keyword 'inverse' is True (default is False), the inverse transformation from x/y to lon/lat is performed. If optional keyword 'errcheck' is True (default is False) an exception is raised if the transformation is invalid. If errcheck=False and the transformation is invalid, no exception is raised and 1.e30 is returned. If the optional keyword 'preserve_units' is True, the units in map projection coordinates are not forced to be meters. Works with numpy and regular python array objects, python sequences and scalars. Attributes ---------- srs: str The string form of the user input used to create the Proj. crs: ~pyproj.crs.CRS The CRS object associated with the Proj. proj_version: int The major version number for PROJ. """ def __init__(self, projparams=None, preserve_units=True, **kwargs): """ initialize a Proj class instance. See the proj documentation (https://github.com/OSGeo/proj.4/wiki) for more information about projection parameters. Parameters ---------- projparams: int, str, dict, pyproj.CRS A proj.4 or WKT string, proj.4 dict, EPSG integer, or a pyproj.CRS instnace. preserve_units: bool If false, will ensure +units=m. **kwargs: proj.4 projection parameters. Example usage: >>> from pyproj import Proj >>> p = Proj(proj='utm',zone=10,ellps='WGS84', preserve_units=False) # use kwargs >>> x,y = p(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> 'lon=%8.3f lat=%5.3f' % p(x,y,inverse=True) 'lon=-120.108 lat=34.361' >>> # do 3 cities at a time in a tuple (Fresno, LA, SF) >>> lons = (-119.72,-118.40,-122.38) >>> lats = (36.77, 33.93, 37.62 ) >>> x,y = p(lons, lats) >>> 'x: %9.3f %9.3f %9.3f' % x 'x: 792763.863 925321.537 554714.301' >>> 'y: %9.3f %9.3f %9.3f' % y 'y: 4074377.617 3763936.941 4163835.303' >>> lons, lats = p(x, y, inverse=True) # inverse transform >>> 'lons: %8.3f %8.3f %8.3f' % lons 'lons: -119.720 -118.400 -122.380' >>> 'lats: %8.3f %8.3f %8.3f' % lats 'lats: 36.770 33.930 37.620' >>> p2 = Proj('+proj=utm +zone=10 +ellps=WGS84', preserve_units=False) # use proj4 string >>> x,y = p2(-120.108, 34.36116666) >>> 'x=%9.3f y=%11.3f' % (x,y) 'x=765975.641 y=3805993.134' >>> p = Proj(init="epsg:32667", preserve_units=False) >>> 'x=%12.3f y=%12.3f (meters)' % p(-114.057222, 51.045) 'x=-1783506.250 y= 6193827.033 (meters)' >>> p = Proj("+init=epsg:32667") >>> 'x=%12.3f y=%12.3f (feet)' % p(-114.057222, 51.045) 'x=-5851386.754 y=20320914.191 (feet)' >>> # test data with radian inputs >>> p1 = Proj(init="epsg:4214") >>> x1, y1 = p1(116.366, 39.867) >>> '{:.3f} {:.3f}'.format(x1, y1) '2.031 0.696' >>> x2, y2 = p1(x1, y1, inverse=True) >>> '{:.3f} {:.3f}'.format(x2, y2) '116.366 39.867' """ self.crs = CRS.from_user_input(projparams if projparams is not None else kwargs) # make sure units are meters if preserve_units is False. if not preserve_units and "foot" in self.crs.axis_info[0].unit_name: projstring = self.crs.to_proj4(4) projstring = re.sub(r"\s\+units=[\w-]+", "", projstring) projstring += " +units=m" self.crs = CRS(projstring) super(Proj, self).__init__( cstrencode( (self.crs.to_proj4() or self.crs.srs).replace("+type=crs", "").strip() ) ) def __call__(self, *args, **kw): # ,lon,lat,inverse=False,errcheck=False): """ Calling a Proj class instance with the arguments lon, lat will convert lon/lat (in degrees) to x/y native map projection coordinates (in meters). If optional keyword 'inverse' is True (default is False), the inverse transformation from x/y to lon/lat is performed. If optional keyword 'errcheck' is True (default is False) an exception is raised if the transformation is invalid. If errcheck=False and the transformation is invalid, no exception is raised and 1.e30 is returned. Inputs should be doubles (they will be cast to doubles if they are not, causing a slight performance hit). Works with numpy and regular python array objects, python sequences and scalars, but is fastest for array objects. """ inverse = kw.get("inverse", False) errcheck = kw.get("errcheck", False) # if len(args) == 1: # latlon = np.array(args[0], copy=True, # order='C', dtype=float, ndmin=2) # if inverse: # _proj.Proj._invn(self, latlon, radians=radians, errcheck=errcheck) # else: # _proj.Proj._fwdn(self, latlon, radians=radians, errcheck=errcheck) # return latlon lon, lat = args # process inputs, making copies that support buffer API. inx, xisfloat, xislist, xistuple = _copytobuffer(lon) iny, yisfloat, yislist, yistuple = _copytobuffer(lat) # call proj4 functions. inx and iny modified in place. if inverse: self._inv(inx, iny, errcheck=errcheck) else: self._fwd(inx, iny, errcheck=errcheck) # if inputs were lists, tuples or floats, convert back. outx = _convertback(xisfloat, xislist, xistuple, inx) outy = _convertback(yisfloat, yislist, xistuple, iny) return outx, outy def is_latlong(self): """ Returns ------- bool: True if projection in geographic (lon/lat) coordinates. """ warnings.warn( "'is_latlong()' is deprecated and will be removed in version 2.2.0. " "Please use 'crs.is_geographic'." ) return self.crs.is_geographic def is_geocent(self): """ Returns ------- bool: True if projection in geocentric (x/y) coordinates """ warnings.warn( "'is_geocent()' is deprecated and will be removed in version 2.2.0. " "Please use 'crs.is_geocent'." ) return self.is_geocent def definition_string(self): """Returns formal definition string for projection >>> Proj('+init=epsg:4326').definition_string() 'proj=longlat datum=WGS84 no_defs ellps=WGS84 towgs84=0,0,0' >>> """ return pystrdecode(self.definition) def to_latlong_def(self): """return the definition string of the geographic (lat/lon) coordinate version of the current projection""" # This is a little hacky way of getting a latlong proj object # Maybe instead of this function the __cinit__ function can take a # Proj object and a type (where type = "geographic") as the libproj # java wrapper return self.crs.to_geodetic().to_proj4(4) # deprecated : using in transform raised a TypeError in release 1.9.5.1 # reported in issue #53, resolved in #73. def to_latlong(self): """return a new Proj instance which is the geographic (lat/lon) coordinate version of the current projection""" return Proj(self.crs.to_geodetic())