- % .@ ^{ui|)(-"R=P_{UvHW±Q5] +@d*jf=xCgt_CvlmcK q:o K ټ=XI|h5?D=+ ߝ_4_tʓ}亿y3Kcg_rRopvS/,- [n>btIIeaÇUA1XO[MP+
֗Vߤ _FGW91)UqzP1vS9Ehof5\ G< DhfzI{I6f?ύ[ǦC49MQ` /L5L!h t ,;eM77iFf-xFe>ay'S[Gīv $f nըn^I g{!#rY">_F\ϭ콝+k$scS& qdꜾ` cȾW1,`jVzFqhXrpb &|]'/`C|Ḷy|.p̍/'`8@Zq3 ś[}fu7ɡu倧s>%Ώl{)=sIe-)o=?ckDզZDn:ZHM;S{Nn:Lǖ{-XPL֮V`wl9 ~]9%~(.'OÜ@MEʏ9{,+ߚW3'?0~SYGs.~R͎'g@|H6i\}3О?ƳՑ] ,gcLpr)
+iT|BG Zhu % onpebc0t:&닕N cw Μ{ut0aJKEn]0=oŧ}N]3/~SOxiGIelTfLo=uRY^^6 drK3ӎ
zOV1\ L5 (
߈+Iob_Ԟ _y`h_^ */ϡ"ۣҪ S9 Pw0Sͤ ?Q\Ei1*bU )NNdKQSVٺ?ߢ~cqjzV`g{
`Ä`lvfl*l6b۹+ˮE Vʛ`<:: W=ˏF>+M LVхN ļf@ p9gh?D\ yLnd۫h_1PW+ dc.>ёa`@@M OD"s&,]k:&'
) for the confidence level.
"""
try:
authority = self.list_authority(
auth_name=auth_name, min_confidence=min_confidence,
)[0]
return authority.auth_name, authority.code
except IndexError:
return None
def list_authority(self, str auth_name=None, int min_confidence=70):
"""
.. versionadded:: 3.2.0
Return the authority names and codes best matching the CRS.
Example:
>>> from pyproj import CRS
>>> ccs = CRS("EPSG:4328")
>>> ccs.list_authority()
[AuthorityMatchInfo(auth_name='EPSG', code='4326', confidence=100)]
If the CRS is bound, you can get an authority from
the source CRS:
>>> from pyproj import CRS
>>> ccs = CRS("+proj=geocent +datum=WGS84 +towgs84=0,0,0")
>>> ccs.list_authority()
[]
>>> ccs.source_crs.list_authority()
[AuthorityMatchInfo(auth_name='EPSG', code='4978', confidence=70)]
>>> ccs == CRS.from_authorty('EPSG', '4978')
False
Parameters
----------
auth_name: str, optional
The name of the authority to filter by.
min_confidence: int, default=70
A value between 0-100 where 100 is the most confident.
:ref:`min_confidence`
Returns
-------
list[AuthorityMatchInfo]:
List of authority matches for the CRS.
"""
# get list of possible matching projections
cdef PJ_OBJ_LIST *proj_list = NULL
cdef int *c_out_confidence_list = NULL
cdef int num_proj_objects = -9999
cdef bytes b_auth_name
cdef char *user_auth_name = NULL
cdef int iii = 0
if auth_name is not None:
b_auth_name = cstrencode(auth_name)
user_auth_name = b_auth_name
out_confidence_list = []
try:
proj_list = proj_identify(
self.context,
self.projobj,
user_auth_name,
NULL,
&c_out_confidence_list
)
if proj_list != NULL:
num_proj_objects = proj_list_get_count(proj_list)
if c_out_confidence_list != NULL and num_proj_objects > 0:
out_confidence_list = [
c_out_confidence_list[iii] for iii in range(num_proj_objects)
]
finally:
if c_out_confidence_list != NULL:
proj_int_list_destroy(c_out_confidence_list)
_clear_proj_error()
# retrieve the best matching projection
cdef PJ* proj = NULL
cdef const char* code
cdef const char* out_auth_name
authority_list = []
try:
for iii in range(num_proj_objects):
if out_confidence_list[iii] < min_confidence:
continue
proj = proj_list_get(self.context, proj_list, iii)
code = proj_get_id_code(proj, 0)
out_auth_name = proj_get_id_auth_name(proj, 0)
if out_auth_name != NULL and code != NULL:
authority_list.append(
AuthorityMatchInfo(
out_auth_name,
code,
out_confidence_list[iii]
)
)
# at this point, the auth name is copied and we can release the proj object
proj_destroy(proj)
proj = NULL
finally:
# If there was an error we have to call proj_destroy
# If there was none, calling it on NULL does nothing
proj_destroy(proj)
proj_list_destroy(proj_list)
_clear_proj_error()
return authority_list
def to_3d(self, str name=None):
"""
.. versionadded:: 3.1.0
Convert the current CRS to the 3D version if it makes sense.
New vertical axis attributes:
- ellipsoidal height
- oriented upwards
- metre units
Parameters
----------
name: str, optional
CRS name. If None, it will use the name of the original CRS.
Returns
-------
_CRS
"""
cdef char* c_name = NULL
cdef bytes b_name
if name is not None:
b_name = cstrencode(name)
c_name = b_name
cdef PJ * projobj = proj_crs_promote_to_3D(
self.context, c_name, self.projobj
)
_clear_proj_error()
if projobj == NULL:
return self
try:
crs_3d = _CRS(_to_wkt(
self.context,
projobj,
version=WktVersion.WKT2_2019,
pretty=False,
))
finally:
proj_destroy(projobj)
return crs_3d
def to_2d(self, str name=None):
"""
.. versionadded:: 3.6.0
Convert the current CRS to the 2D version if it makes sense.
Parameters
----------
name: str, optional
CRS name. If None, it will use the name of the original CRS.
Returns
-------
_CRS
"""
cdef char* c_name = NULL
cdef bytes b_name
if name is not None:
b_name = cstrencode(name)
c_name = b_name
cdef PJ * projobj = proj_crs_demote_to_2D(
self.context, c_name, self.projobj
)
_clear_proj_error()
if projobj == NULL:
return self
try:
crs_2d = _CRS(_to_wkt(
self.context,
projobj,
version=WktVersion.WKT2_2019,
pretty=False,
))
finally:
proj_destroy(projobj)
return crs_2d
def _is_crs_property(
self, str property_name, tuple property_types, int sub_crs_index=0
):
"""
.. versionadded:: 2.2.0
This method will check for a property on the CRS.
It will check if it has the property on the sub CRS
if it is a compound CRS and will check if the source CRS
has the property if it is a bound CRS.
Parameters
----------
property_name: str
The name of the CRS property.
property_types: tuple(PJ_TYPE)
The types to check for for the property.
sub_crs_index: int, default=0
THe index of the CRS in the sub CRS list.
Returns
-------
bool:
True if the CRS has this property.
"""
if self.sub_crs_list:
sub_crs = self.sub_crs_list[sub_crs_index]
if sub_crs.is_bound:
is_property = getattr(sub_crs.source_crs, property_name)
else:
is_property = getattr(sub_crs, property_name)
elif self.is_bound:
is_property = getattr(self.source_crs, property_name)
else:
is_property = self._type in property_types
return is_property
@property
def is_geographic(self):
"""
This checks if the CRS is geographic.
It will check if it has a geographic CRS
in the sub CRS if it is a compound CRS and will check if
the source CRS is geographic if it is a bound CRS.
Returns
-------
bool:
True if the CRS is in geographic (lon/lat) coordinates.
"""
return self._is_crs_property(
"is_geographic",
(
PJ_TYPE_GEOGRAPHIC_CRS,
PJ_TYPE_GEOGRAPHIC_2D_CRS,
PJ_TYPE_GEOGRAPHIC_3D_CRS
)
)
@property
def is_projected(self):
"""
This checks if the CRS is projected.
It will check if it has a projected CRS
in the sub CRS if it is a compound CRS and will check if
the source CRS is projected if it is a bound CRS.
Returns
-------
bool:
True if CRS is projected.
"""
return self._is_crs_property(
"is_projected",
(PJ_TYPE_PROJECTED_CRS,)
)
@property
def is_vertical(self):
"""
.. versionadded:: 2.2.0
This checks if the CRS is vertical.
It will check if it has a vertical CRS
in the sub CRS if it is a compound CRS and will check if
the source CRS is vertical if it is a bound CRS.
Returns
-------
bool:
True if CRS is vertical.
"""
return self._is_crs_property(
"is_vertical",
(PJ_TYPE_VERTICAL_CRS,),
sub_crs_index=1
)
@property
def is_bound(self):
"""
Returns
-------
bool:
True if CRS is bound.
"""
return self._type == PJ_TYPE_BOUND_CRS
@property
def is_compound(self):
"""
.. versionadded:: 3.1.0
Returns
-------
bool:
True if CRS is compound.
"""
return self._type == PJ_TYPE_COMPOUND_CRS
@property
def is_engineering(self):
"""
.. versionadded:: 2.2.0
Returns
-------
bool:
True if CRS is local/engineering.
"""
return self._type == PJ_TYPE_ENGINEERING_CRS
@property
def is_geocentric(self):
"""
This checks if the CRS is geocentric and
takes into account if the CRS is bound.
Returns
-------
bool:
True if CRS is in geocentric (x/y) coordinates.
"""
if self.is_bound:
return self.source_crs.is_geocentric
return self._type == PJ_TYPE_GEOCENTRIC_CRS
@property
def is_derived(self):
"""
.. versionadded:: 3.2.0
Returns
-------
bool:
True if CRS is a Derived CRS.
"""
return proj_is_derived_crs(self.context, self.projobj) == 1
def _equals(self, _CRS other, bint ignore_axis_order):
if ignore_axis_order:
# Only to be used with DerivedCRS/ProjectedCRS/GeographicCRS
return proj_is_equivalent_to_with_ctx(
self.context,
self.projobj,
other.projobj,
PJ_COMP_EQUIVALENT_EXCEPT_AXIS_ORDER_GEOGCRS,
) == 1
return self._is_equivalent(other)
def equals(self, other, ignore_axis_order=False):
"""
Check if the projection objects are equivalent.
Properties
----------
other: CRS
Check if the other object
ignore_axis_order: bool, default=False
If True, it will compare the CRS class and ignore the axis order.
Returns
-------
bool
"""
if not isinstance(other, _CRS):
return False
return self._equals(other, ignore_axis_order=ignore_axis_order)
pyproj-3.6.1/pyproj/_datadir.pxd 0000664 0000000 0000000 00000000371 14502715416 0016661 0 ustar 00root root 0000000 0000000 include "proj.pxi"
cpdef str _get_proj_error() noexcept
cpdef void _clear_proj_error() noexcept
cdef PJ_CONTEXT* PYPROJ_GLOBAL_CONTEXT
cdef PJ_CONTEXT* pyproj_context_create() except *
cdef void pyproj_context_destroy(PJ_CONTEXT* context) except *
pyproj-3.6.1/pyproj/_datadir.pyi 0000664 0000000 0000000 00000000510 14502715416 0016662 0 ustar 00root root 0000000 0000000 from typing import Optional
def _pyproj_global_context_initialize() -> None: ...
def get_user_data_dir(create: bool = False) -> str: ...
def _global_context_set_data_dir() -> None: ...
def set_use_global_context(active: Optional[bool] = None) -> None: ...
def _clear_proj_error() -> None: ...
def _get_proj_error() -> str: ...
pyproj-3.6.1/pyproj/_datadir.pyx 0000664 0000000 0000000 00000014744 14502715416 0016717 0 ustar 00root root 0000000 0000000 import logging
import os
import warnings
from libc.stdlib cimport free, malloc
from pyproj._compat cimport cstrencode
from pyproj.utils import strtobool
# for logging the internal PROJ messages
# https://docs.python.org/3/howto/logging.html#configuring-logging-for-a-library
_LOGGER = logging.getLogger("pyproj")
_LOGGER.addHandler(logging.NullHandler())
# default to False is the safest mode
# as it supports multithreading
_USE_GLOBAL_CONTEXT = strtobool(os.environ.get("PYPROJ_GLOBAL_CONTEXT", "OFF"))
# static user data directory to prevent core dumping
# see: https://github.com/pyproj4/pyproj/issues/678
cdef const char* _USER_DATA_DIR = proj_context_get_user_writable_directory(NULL, False)
# Store the message from any internal PROJ errors
cdef str _INTERNAL_PROJ_ERROR = None
def set_use_global_context(active=None):
"""
.. versionadded:: 3.0.0
Activates the usage of the global context. Using this
option can enhance the performance of initializing objects
in single-threaded applications.
.. warning:: The global context is not thread safe.
.. warning:: The global context maintains a connection to the database
through the duration of each python session and is closed
once the program terminates.
.. note:: To modify network settings see: :ref:`network`.
Parameters
----------
active: bool, optional
If True, it activates the use of the global context. If False,
the use of the global context is deactivated. If None, it uses
the environment variable PYPROJ_GLOBAL_CONTEXT and defaults
to False if it is not found.
"""
global _USE_GLOBAL_CONTEXT
if active is None:
active = strtobool(os.environ.get("PYPROJ_GLOBAL_CONTEXT", "OFF"))
_USE_GLOBAL_CONTEXT = bool(active)
def get_user_data_dir(create=False):
"""
.. versionadded:: 3.0.0
Get the PROJ user writable directory for datumgrid files.
See: :c:func:`proj_context_get_user_writable_directory`
This is where grids will be downloaded when
:ref:`PROJ network ` capabilities
are enabled. It is also the default download location for the
:ref:`projsync` command line program.
Parameters
----------
create: bool, default=False
If True, it will create the directory if it does not already exist.
Returns
-------
str:
The user writable data directory.
"""
return proj_context_get_user_writable_directory(
PYPROJ_GLOBAL_CONTEXT, bool(create)
)
cpdef str _get_proj_error() noexcept:
"""
Get the internal PROJ error message. Returns None if no error was set.
"""
return _INTERNAL_PROJ_ERROR
cpdef void _clear_proj_error() noexcept:
"""
Clear the internal PROJ error message.
"""
global _INTERNAL_PROJ_ERROR
_INTERNAL_PROJ_ERROR = None
cdef void pyproj_log_function(void *user_data, int level, const char *error_msg) nogil noexcept:
"""
Log function for catching PROJ errors.
"""
# from pyproj perspective, everything from PROJ is for debugging.
# The verbosity should be managed via the
# PROJ_DEBUG environment variable.
if level == PJ_LOG_ERROR:
with gil:
global _INTERNAL_PROJ_ERROR
_INTERNAL_PROJ_ERROR = error_msg
_LOGGER.debug(f"PROJ_ERROR: {_INTERNAL_PROJ_ERROR}")
elif level == PJ_LOG_DEBUG:
with gil:
_LOGGER.debug(f"PROJ_DEBUG: {error_msg}")
elif level == PJ_LOG_TRACE:
with gil:
_LOGGER.debug(f"PROJ_TRACE: {error_msg}")
cdef void set_context_data_dir(PJ_CONTEXT* context) except *:
"""
Setup the data directory for the context for pyproj
"""
from pyproj.datadir import get_data_dir
data_dir_list = get_data_dir().split(os.pathsep)
# the first path will always have the database
cdef bytes b_database_path = cstrencode(os.path.join(data_dir_list[0], "proj.db"))
cdef const char* c_database_path = b_database_path
if not proj_context_set_database_path(context, c_database_path, NULL, NULL):
warnings.warn("pyproj unable to set database path.")
cdef int dir_list_len = len(data_dir_list)
cdef const char **c_data_dir = malloc(
(dir_list_len + 1) * sizeof(const char*)
)
cdef bytes b_data_dir
try:
for iii in range(dir_list_len):
b_data_dir = cstrencode(data_dir_list[iii])
c_data_dir[iii] = b_data_dir
c_data_dir[dir_list_len] = _USER_DATA_DIR
proj_context_set_search_paths(context, dir_list_len + 1, c_data_dir)
finally:
free(c_data_dir)
cdef void pyproj_context_initialize(PJ_CONTEXT* context) except *:
"""
Setup the context for pyproj
"""
proj_log_func(context, NULL, pyproj_log_function)
proj_context_use_proj4_init_rules(context, 1)
set_context_data_dir(context)
cdef class ContextManager:
"""
The only purpose of this class is
to ensure the context is cleaned up properly.
"""
cdef PJ_CONTEXT* context
def __cinit__(self):
self.context = NULL
def __dealloc__(self):
if self.context != NULL:
proj_context_destroy(self.context)
@staticmethod
cdef create(PJ_CONTEXT* context):
cdef ContextManager context_manager = ContextManager()
context_manager.context = context
return context_manager
# Different libraries that modify the PROJ global context will influence
# each other without realizing it. Due to this, pyproj is creating it's own
# global context so that it doesn't bother other libraries and is insulated
# against possible external changes made to the PROJ global context.
# See: https://github.com/pyproj4/pyproj/issues/722
cdef PJ_CONTEXT* PYPROJ_GLOBAL_CONTEXT = proj_context_create()
cdef ContextManager CONTEXT_MANAGER = ContextManager.create(PYPROJ_GLOBAL_CONTEXT)
cdef PJ_CONTEXT* pyproj_context_create() except *:
"""
Create and initialize the context(s) for pyproj.
This also manages whether the global context is used.
"""
if _USE_GLOBAL_CONTEXT:
return PYPROJ_GLOBAL_CONTEXT
return proj_context_clone(PYPROJ_GLOBAL_CONTEXT)
cdef void pyproj_context_destroy(PJ_CONTEXT* context) except *:
"""
Destroy context only if not the global context
"""
if context != PYPROJ_GLOBAL_CONTEXT:
proj_context_destroy(context)
cpdef _pyproj_global_context_initialize():
pyproj_context_initialize(PYPROJ_GLOBAL_CONTEXT)
cpdef _global_context_set_data_dir():
set_context_data_dir(PYPROJ_GLOBAL_CONTEXT)
pyproj-3.6.1/pyproj/_geod.pxd 0000664 0000000 0000000 00000003347 14502715416 0016175 0 ustar 00root root 0000000 0000000 cdef extern from "geodesic.h" nogil:
struct geod_geodesic:
pass
struct geod_geodesicline:
double lat1
double lon1
double azi1
double a
double f
double salp1
double calp1
double a13
double s13
unsigned caps
void geod_init(geod_geodesic* g, double a, double f)
void geod_direct(
geod_geodesic* g,
double lat1,
double lon1,
double azi1,
double s12,
double* plat2,
double* plon2,
double* pazi2)
void geod_inverse(
geod_geodesic* g,
double lat1,
double lon1,
double lat2,
double lon2,
double* ps12,
double* pazi1,
double* pazi2)
void geod_lineinit(
geod_geodesicline* l,
const geod_geodesic* g,
double lat1,
double lon1,
double azi1,
unsigned caps)
void geod_inverseline(
geod_geodesicline* l,
const geod_geodesic* g,
double lat1,
double lon1,
double lat2,
double lon2,
unsigned caps)
void geod_position(
geod_geodesicline* l,
double s12,
double* plat2,
double* plon2,
double* pazi2)
void geod_polygonarea(
geod_geodesic* g,
double lats[],
double lons[],
int n,
double* pA,
double* pP)
cdef enum:
GEODESIC_VERSION_MAJOR
GEODESIC_VERSION_MINOR
GEODESIC_VERSION_PATCH
cdef class Geod:
cdef geod_geodesic _geod_geodesic
cdef readonly object initstring
cdef readonly double a
cdef readonly double b
cdef readonly double f
cdef readonly double es
cdef readonly bint sphere
pyproj-3.6.1/pyproj/_geod.pyi 0000664 0000000 0000000 00000004033 14502715416 0016174 0 ustar 00root root 0000000 0000000 from typing import Any, NamedTuple
geodesic_version_str: str
class GeodIntermediateReturn(NamedTuple):
npts: int
del_s: float
dist: float
lons: Any
lats: Any
azis: Any
class Geod:
initstring: str
a: float
b: float
f: float
es: float
sphere: bool
def __init__(
self, a: float, f: float, sphere: bool, b: float, es: float
) -> None: ...
def __reduce__(self) -> tuple[type["Geod"], str]: ...
def __repr__(self) -> str: ...
def _fwd(
self,
lons: Any,
lats: Any,
az: Any,
dist: Any,
radians: bool = False,
return_back_azimuth: bool = True,
) -> None: ...
def _fwd_point(
self,
lons: float,
lats: float,
az: float,
dist: float,
radians: bool = False,
return_back_azimuth: bool = True,
) -> tuple[float, float, float]: ...
def _inv(
self,
lons1: Any,
lats1: Any,
lons2: Any,
lats2: Any,
radians: bool = False,
return_back_azimuth: bool = False,
) -> None: ...
def _inv_point(
self,
lons1: float,
lats1: float,
lons2: float,
lats2: float,
radians: bool = False,
return_back_azimuth: bool = False,
) -> tuple[float, float, float]: ...
def _inv_or_fwd_intermediate(
self,
lon1: float,
lat1: float,
lon2_or_azi1: float,
lat2: float,
npts: int,
del_s: float,
radians: bool,
initial_idx: int,
terminus_idx: int,
flags: int,
out_lons: Any,
out_lats: Any,
out_azis: Any,
return_back_azimuth: bool,
is_fwd: bool,
) -> GeodIntermediateReturn: ...
def _line_length(self, lons: Any, lats: Any, radians: bool = False) -> float: ...
def _polygon_area_perimeter(
self, lons: Any, lats: Any, radians: bool = False
) -> tuple[float, float]: ...
def reverse_azimuth(azi: Any, radians: bool = False) -> None: ...
pyproj-3.6.1/pyproj/_geod.pyx 0000664 0000000 0000000 00000050646 14502715416 0016226 0 ustar 00root root 0000000 0000000 include "base.pxi"
cimport cython
from libc.math cimport ceil, isnan, round
from pyproj._compat cimport cstrencode, empty_array
import math
from collections import namedtuple
from pyproj.enums import GeodIntermediateFlag
from pyproj.exceptions import GeodError
geodesic_version_str = (
f"{GEODESIC_VERSION_MAJOR}.{GEODESIC_VERSION_MINOR}.{GEODESIC_VERSION_PATCH}"
)
GeodIntermediateReturn = namedtuple(
"GeodIntermediateReturn", ["npts", "del_s", "dist", "lons", "lats", "azis"]
)
GeodIntermediateReturn.__doc__ = """
.. versionadded:: 3.1.0
Geod Intermediate Return value (Named Tuple)
Parameters
----------
npts: int
number of points
del_s: float
delimiter distance between two successive points
dist: float
distance between the initial and terminus points
out_lons: Any
array of the output lons
out_lats: Any
array of the output lats
out_azis: Any
array of the output azis
"""
cdef:
int GEOD_INTER_FLAG_DEFAULT = GeodIntermediateFlag.DEFAULT
int GEOD_INTER_FLAG_NPTS_MASK = (
GeodIntermediateFlag.NPTS_ROUND
| GeodIntermediateFlag.NPTS_CEIL
| GeodIntermediateFlag.NPTS_TRUNC
)
int GEOD_INTER_FLAG_NPTS_ROUND = GeodIntermediateFlag.NPTS_ROUND
int GEOD_INTER_FLAG_NPTS_CEIL = GeodIntermediateFlag.NPTS_CEIL
int GEOD_INTER_FLAG_NPTS_TRUNC = GeodIntermediateFlag.NPTS_TRUNC
int GEOD_INTER_FLAG_DEL_S_MASK = (
GeodIntermediateFlag.DEL_S_RECALC | GeodIntermediateFlag.DEL_S_NO_RECALC
)
int GEOD_INTER_FLAG_DEL_S_RECALC = GeodIntermediateFlag.DEL_S_RECALC
int GEOD_INTER_FLAG_DEL_S_NO_RECALC = GeodIntermediateFlag.DEL_S_NO_RECALC
int GEOD_INTER_FLAG_AZIS_MASK = (
GeodIntermediateFlag.AZIS_DISCARD | GeodIntermediateFlag.AZIS_KEEP
)
int GEOD_INTER_FLAG_AZIS_DISCARD = GeodIntermediateFlag.AZIS_DISCARD
int GEOD_INTER_FLAG_AZIS_KEEP = GeodIntermediateFlag.AZIS_KEEP
cdef double _reverse_azimuth(double azi, double factor) nogil:
if azi > 0:
azi = azi - factor
else:
azi = azi + factor
return azi
def reverse_azimuth(object azi, bint radians=False):
cdef PyBuffWriteManager azibuff = PyBuffWriteManager(azi)
cdef Py_ssize_t iii
cdef double factor = 180
if radians:
factor = math.pi
with nogil:
for iii in range(azibuff.len):
azibuff.data[iii] = _reverse_azimuth(azibuff.data[iii], factor=factor)
cdef class Geod:
def __init__(self, double a, double f, bint sphere, double b, double es):
geod_init(&self._geod_geodesic, a, f)
self.a = a
self.f = f
# convert 'a' only for initstring
a_str = int(a) if a.is_integer() else a
f_str = int(f) if f.is_integer() else f
self.initstring = f"+a={a_str} +f={f_str}"
self.sphere = sphere
self.b = b
self.es = es
def __reduce__(self):
"""special method that allows pyproj.Geod instance to be pickled"""
return self.__class__, (self.initstring,)
@cython.boundscheck(False)
@cython.wraparound(False)
def _fwd(
self,
object lons,
object lats,
object az,
object dist,
bint radians=False,
bint return_back_azimuth=True,
):
"""
forward transformation - determine longitude, latitude and back azimuth
of a terminus point given an initial point longitude and latitude, plus
forward azimuth and distance.
if radians=True, lons/lats are radians instead of degrees.
if return_back_azimuth=True, the return azimuth will be the forward azimuth instead of the forward azimuth.
"""
cdef:
PyBuffWriteManager lonbuff = PyBuffWriteManager(lons)
PyBuffWriteManager latbuff = PyBuffWriteManager(lats)
PyBuffWriteManager azbuff = PyBuffWriteManager(az)
PyBuffWriteManager distbuff = PyBuffWriteManager(dist)
# process data in buffer
if not lonbuff.len == latbuff.len == azbuff.len == distbuff.len:
raise GeodError("Array lengths are not the same.")
cdef:
double lat1
double lon1
double az1
double s12
double plon2
double plat2
double pazi2
Py_ssize_t iii
with nogil:
for iii in range(lonbuff.len):
if not radians:
lon1 = lonbuff.data[iii]
lat1 = latbuff.data[iii]
az1 = azbuff.data[iii]
s12 = distbuff.data[iii]
else:
lon1 = _RAD2DG * lonbuff.data[iii]
lat1 = _RAD2DG * latbuff.data[iii]
az1 = _RAD2DG * azbuff.data[iii]
s12 = distbuff.data[iii]
geod_direct(
&self._geod_geodesic,
lat1,
lon1,
az1,
s12,
&plat2,
&plon2,
&pazi2,
)
# by default (return_back_azimuth=True),
# forward azimuth needs to be flipped 180 degrees
# to match the (back azimuth) output of PROJ geod utilities.
if return_back_azimuth:
pazi2 = _reverse_azimuth(pazi2, factor=180)
if not radians:
lonbuff.data[iii] = plon2
latbuff.data[iii] = plat2
azbuff.data[iii] = pazi2
else:
lonbuff.data[iii] = _DG2RAD * plon2
latbuff.data[iii] = _DG2RAD * plat2
azbuff.data[iii] = _DG2RAD * pazi2
@cython.boundscheck(False)
@cython.wraparound(False)
def _fwd_point(
self,
object lon1in,
object lat1in,
object az1in,
object s12in,
bint radians=False,
bint return_back_azimuth=True,
):
"""
Scalar optimized function
forward transformation - determine longitude, latitude and back azimuth
of a terminus point given an initial point longitude and latitude, plus
forward azimuth and distance.
if radians=True, lons/lats are radians instead of degrees.
"""
cdef:
double plon2
double plat2
double pazi2
double lon1 = lon1in
double lat1 = lat1in
double az1 = az1in
double s12 = s12in
# We do the type-checking internally here due to automatically
# casting length-1 arrays to float that we don't want to return scalar for.
# Ex: float(np.array([0])) works and we don't want to accept numpy arrays
for x_in in (lon1in, lat1in, az1in, s12in):
if not isinstance(x_in, (float, int)):
raise TypeError("Scalar input is required for point based functions")
with nogil:
if radians:
lon1 = _RAD2DG * lon1
lat1 = _RAD2DG * lat1
az1 = _RAD2DG * az1
geod_direct(
&self._geod_geodesic,
lat1,
lon1,
az1,
s12,
&plat2,
&plon2,
&pazi2,
)
# back azimuth needs to be flipped 180 degrees
# to match what PROJ geod utility produces.
if return_back_azimuth:
pazi2 =_reverse_azimuth(pazi2, factor=180)
if radians:
plon2 = _DG2RAD * plon2
plat2 = _DG2RAD * plat2
pazi2 = _DG2RAD * pazi2
return plon2, plat2, pazi2
@cython.boundscheck(False)
@cython.wraparound(False)
def _inv(
self,
object lons1,
object lats1,
object lons2,
object lats2,
bint radians=False,
bint return_back_azimuth=True,
):
"""
inverse transformation - return forward azimuth (azi12) and back azimuths (azi21), plus distance
between an initial and terminus lat/lon pair.
if radians=True, lons/lats are radians instead of degree
if return_back_azimuth=True, azi21 is a back azimuth (180 degrees flipped),
otherwise azi21 is also a forward azimuth.
"""
cdef:
PyBuffWriteManager lon1buff = PyBuffWriteManager(lons1)
PyBuffWriteManager lat1buff = PyBuffWriteManager(lats1)
PyBuffWriteManager lon2buff = PyBuffWriteManager(lons2)
PyBuffWriteManager lat2buff = PyBuffWriteManager(lats2)
# process data in buffer
if not lon1buff.len == lat1buff.len == lon2buff.len == lat2buff.len:
raise GeodError("Array lengths are not the same.")
cdef:
double lat1
double lon1
double lat2
double lon2
double pazi1
double pazi2
double ps12
Py_ssize_t iii
with nogil:
for iii in range(lon1buff.len):
if radians:
lon1 = _RAD2DG * lon1buff.data[iii]
lat1 = _RAD2DG * lat1buff.data[iii]
lon2 = _RAD2DG * lon2buff.data[iii]
lat2 = _RAD2DG * lat2buff.data[iii]
else:
lon1 = lon1buff.data[iii]
lat1 = lat1buff.data[iii]
lon2 = lon2buff.data[iii]
lat2 = lat2buff.data[iii]
geod_inverse(
&self._geod_geodesic,
lat1, lon1, lat2, lon2,
&ps12, &pazi1, &pazi2,
)
# by default (return_back_azimuth=True),
# forward azimuth needs to be flipped 180 degrees
# to match the (back azimuth) output of PROJ geod utilities.
if return_back_azimuth:
pazi2 = _reverse_azimuth(pazi2, factor=180)
if radians:
lon1buff.data[iii] = _DG2RAD * pazi1
lat1buff.data[iii] = _DG2RAD * pazi2
else:
lon1buff.data[iii] = pazi1
lat1buff.data[iii] = pazi2
# write azimuth data into lon2 buffer
lon2buff.data[iii] = ps12
@cython.boundscheck(False)
@cython.wraparound(False)
def _inv_point(
self,
object lon1in,
object lat1in,
object lon2in,
object lat2in,
bint radians=False,
bint return_back_azimuth=True,
):
"""
Scalar optimized function
inverse transformation - return forward and back azimuth, plus distance
between an initial and terminus lat/lon pair.
if radians=True, lons/lats are radians instead of degree
"""
cdef:
double pazi1
double pazi2
double ps12
double lon1 = lon1in
double lat1 = lat1in
double lon2 = lon2in
double lat2 = lat2in
# We do the type-checking internally here due to automatically
# casting length-1 arrays to float that we don't want to return scalar for.
# Ex: float(np.array([0])) works and we don't want to accept numpy arrays
for x_in in (lon1in, lat1in, lon2in, lat2in):
if not isinstance(x_in, (float, int)):
raise TypeError("Scalar input is required for point based functions")
with nogil:
if radians:
lon1 = _RAD2DG * lon1
lat1 = _RAD2DG * lat1
lon2 = _RAD2DG * lon2
lat2 = _RAD2DG * lat2
geod_inverse(
&self._geod_geodesic,
lat1, lon1, lat2, lon2,
&ps12, &pazi1, &pazi2,
)
# back azimuth needs to be flipped 180 degrees
# to match what proj4 geod utility produces.
if return_back_azimuth:
pazi2 =_reverse_azimuth(pazi2, factor=180)
if radians:
pazi1 = _DG2RAD * pazi1
pazi2 = _DG2RAD * pazi2
return pazi1, pazi2, ps12
@cython.boundscheck(False)
@cython.wraparound(False)
def _inv_or_fwd_intermediate(
self,
double lon1,
double lat1,
double lon2_or_azi1,
double lat2,
int npts,
double del_s,
bint radians,
int initial_idx,
int terminus_idx,
int flags,
object out_lons,
object out_lats,
object out_azis,
bint return_back_azimuth,
bint is_fwd,
) -> GeodIntermediateReturn:
"""
.. versionadded:: 3.1.0
given initial and terminus lat/lon, find npts intermediate points.
using given lons, lats buffers
"""
cdef:
Py_ssize_t iii
double pazi2
double s12
double plon2
double plat2
geod_geodesicline line
bint store_az = (
out_azis is not None or
(flags & GEOD_INTER_FLAG_AZIS_MASK) == GEOD_INTER_FLAG_AZIS_KEEP
)
PyBuffWriteManager lons_buff
PyBuffWriteManager lats_buff
PyBuffWriteManager azis_buff
if not is_fwd and (del_s == 0) == (npts == 0):
raise GeodError("inv_intermediate: "
"npts and del_s are mutually exclusive, "
"only one of them must be != 0.")
with nogil:
if radians:
lon1 *= _RAD2DG
lat1 *= _RAD2DG
lon2_or_azi1 *= _RAD2DG
if not is_fwd:
lat2 *= _RAD2DG
if is_fwd:
# do fwd computation to set azimuths, distance.
geod_lineinit(&line, &self._geod_geodesic, lat1, lon1, lon2_or_azi1, 0u)
line.s13 = del_s * (npts + initial_idx + terminus_idx - 1)
else:
# do inverse computation to set azimuths, distance.
geod_inverseline(&line, &self._geod_geodesic, lat1, lon1,
lat2, lon2_or_azi1, 0u)
if npts == 0:
# calc the number of required points by the distance increment
# s12 holds a temporary float value of npts (just reusing this var)
s12 = line.s13 / del_s - initial_idx - terminus_idx + 1
if (flags & GEOD_INTER_FLAG_NPTS_MASK) == \
GEOD_INTER_FLAG_NPTS_ROUND:
s12 = round(s12)
elif (flags & GEOD_INTER_FLAG_NPTS_MASK) == \
GEOD_INTER_FLAG_NPTS_CEIL:
s12 = ceil(s12)
npts = int(s12)
if (flags & GEOD_INTER_FLAG_DEL_S_MASK) == GEOD_INTER_FLAG_DEL_S_RECALC:
# calc the distance increment by the number of required points
del_s = line.s13 / (npts + initial_idx + terminus_idx - 1)
with gil:
if out_lons is None:
out_lons = empty_array(npts)
if out_lats is None:
out_lats = empty_array(npts)
if out_azis is None and store_az:
out_azis = empty_array(npts)
lons_buff = PyBuffWriteManager(out_lons)
lats_buff = PyBuffWriteManager(out_lats)
if store_az:
azis_buff = PyBuffWriteManager(out_azis)
if lons_buff.len < npts \
or lats_buff.len < npts \
or (store_az and azis_buff.len < npts):
raise GeodError(
"Arrays are not long enough ("
f"{lons_buff.len}, {lats_buff.len}, "
f"{azis_buff.len if store_az else -1}) < {npts}.")
# loop over intermediate points, compute lat/lons.
for iii in range(0, npts):
s12 = (iii + initial_idx) * del_s
geod_position(&line, s12, &plat2, &plon2, &pazi2)
if radians:
plat2 *= _DG2RAD
plon2 *= _DG2RAD
lats_buff.data[iii] = plat2
lons_buff.data[iii] = plon2
if store_az:
# by default (return_back_azimuth=True),
# forward azimuth needs to be flipped 180 degrees
# to match the (back azimuth) output of PROJ geod utilities.
if return_back_azimuth:
pazi2 =_reverse_azimuth(pazi2, factor=180)
azis_buff.data[iii] = pazi2
return GeodIntermediateReturn(
npts, del_s, line.s13, out_lons, out_lats, out_azis)
@cython.boundscheck(False)
@cython.wraparound(False)
def _line_length(self, object lons, object lats, bint radians=False):
"""
Calculate the distance between points along a line.
Parameters
----------
lons: array
The longitude points along a line.
lats: array
The latitude points along a line.
radians: bool, default=False
If True, the input data is assumed to be in radians.
Returns
-------
float:
The total distance.
"""
cdef PyBuffWriteManager lonbuff = PyBuffWriteManager(lons)
cdef PyBuffWriteManager latbuff = PyBuffWriteManager(lats)
# process data in buffer
if lonbuff.len != latbuff.len:
raise GeodError("Array lengths are not the same.")
if lonbuff.len == 1:
lonbuff.data[0] = 0
return 0.0
cdef:
double lat1
double lon1
double lat2
double lon2
double pazi1
double pazi2
double ps12
double total_distance = 0.0
Py_ssize_t iii
with nogil:
for iii in range(lonbuff.len - 1):
if radians:
lon1 = _RAD2DG * lonbuff.data[iii]
lat1 = _RAD2DG * latbuff.data[iii]
lon2 = _RAD2DG * lonbuff.data[iii + 1]
lat2 = _RAD2DG * latbuff.data[iii + 1]
else:
lon1 = lonbuff.data[iii]
lat1 = latbuff.data[iii]
lon2 = lonbuff.data[iii + 1]
lat2 = latbuff.data[iii + 1]
geod_inverse(
&self._geod_geodesic,
lat1, lon1, lat2, lon2,
&ps12, &pazi1, &pazi2,
)
lonbuff.data[iii] = ps12
total_distance += ps12
return total_distance
@cython.boundscheck(False)
@cython.wraparound(False)
def _polygon_area_perimeter(self, object lons, object lats, bint radians=False):
"""
A simple interface for computing the area of a geodesic polygon.
lats should be in the range [-90 deg, 90 deg].
Only simple polygons (which are not self-intersecting) are allowed.
There's no need to "close" the polygon by repeating the first vertex.
The area returned is signed with counter-clockwise traversal being treated as
positive.
Parameters
----------
lons: array
An array of longitude values.
lats: array
An array of latitude values.
radians: bool, default=False
If True, the input data is assumed to be in radians.
Returns
-------
(float, float):
The area (meter^2) and perimeter (meters) of the polygon.
"""
cdef PyBuffWriteManager lonbuff = PyBuffWriteManager(lons)
cdef PyBuffWriteManager latbuff = PyBuffWriteManager(lats)
# process data in buffer
if not lonbuff.len == latbuff.len:
raise GeodError("Array lengths are not the same.")
cdef double polygon_area
cdef double polygon_perimeter
cdef Py_ssize_t iii
with nogil:
if radians:
for iii in range(lonbuff.len):
lonbuff.data[iii] *= _RAD2DG
latbuff.data[iii] *= _RAD2DG
geod_polygonarea(
&self._geod_geodesic,
latbuff.data, lonbuff.data, lonbuff.len,
&polygon_area, &polygon_perimeter
)
return (polygon_area, polygon_perimeter)
def __repr__(self):
return f"{self.__class__.__name__}({self.initstring!r})"
pyproj-3.6.1/pyproj/_network.pyi 0000664 0000000 0000000 00000000301 14502715416 0016741 0 ustar 00root root 0000000 0000000 from typing import Optional
def set_network_enabled(active: Optional[bool] = None) -> None: ...
def is_network_enabled() -> bool: ...
def _set_ca_bundle_path(ca_bundle_path: str) -> None: ...
pyproj-3.6.1/pyproj/_network.pyx 0000664 0000000 0000000 00000003276 14502715416 0016776 0 ustar 00root root 0000000 0000000 include "proj.pxi"
import os
from pyproj.utils import strtobool
from pyproj._compat cimport cstrencode
from pyproj._datadir cimport PYPROJ_GLOBAL_CONTEXT
def _set_ca_bundle_path(str ca_bundle_path):
"""
Sets the path to the CA Bundle used by the `curl`
built into PROJ.
Parameters
----------
ca_bundle_path: str
The path to the CA Bundle.
"""
proj_context_set_ca_bundle_path(PYPROJ_GLOBAL_CONTEXT, cstrencode(ca_bundle_path))
def set_network_enabled(active=None):
"""
.. versionadded:: 3.0.0
Set whether PROJ network is enabled by default. This has the same
behavior as the `PROJ_NETWORK` environment variable.
See: :c:func:`proj_context_set_enable_network`
Parameters
----------
active: 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.
"""
if active is None:
# in the case of the global context, need to reset network
# setting based on the environment variable every time if None
# because it could have been changed by the user previously
active = strtobool(os.environ.get("PROJ_NETWORK", "OFF"))
proj_context_set_enable_network(PYPROJ_GLOBAL_CONTEXT, bool(active))
def is_network_enabled():
"""
.. versionadded:: 3.0.0
See: :c:func:`proj_context_is_network_enabled`
Returns
-------
bool:
If PROJ network is enabled by default.
"""
return proj_context_is_network_enabled(PYPROJ_GLOBAL_CONTEXT) == 1
pyproj-3.6.1/pyproj/_show_versions.py 0000664 0000000 0000000 00000005613 14502715416 0020022 0 ustar 00root root 0000000 0000000 """
Utility methods to print system info for debugging
adapted from :func:`sklearn.utils._show_versions`
which was adapted from :func:`pandas.show_versions`
"""
import importlib.metadata
import platform
import sys
def _get_sys_info():
"""System information
Return
------
sys_info : dict
system and Python version information
"""
blob = [
("python", sys.version.replace("\n", " ")),
("executable", sys.executable),
("machine", platform.platform()),
]
return dict(blob)
def _get_proj_info():
"""Information on system PROJ
Returns
-------
proj_info: dict
system PROJ information
"""
# pylint: disable=import-outside-toplevel
import pyproj
from pyproj.database import get_database_metadata
from pyproj.exceptions import DataDirError
try:
data_dir = pyproj.datadir.get_data_dir()
except DataDirError:
data_dir = None
blob = [
("pyproj", pyproj.__version__),
("PROJ", pyproj.__proj_version__),
("data dir", data_dir),
("user_data_dir", pyproj.datadir.get_user_data_dir()),
("PROJ DATA (recommended version)", get_database_metadata("PROJ_DATA.VERSION")),
(
"PROJ Database",
f"{get_database_metadata('DATABASE.LAYOUT.VERSION.MAJOR')}."
f"{get_database_metadata('DATABASE.LAYOUT.VERSION.MINOR')}",
),
(
"EPSG Database",
f"{get_database_metadata('EPSG.VERSION')} "
f"[{get_database_metadata('EPSG.DATE')}]",
),
(
"ESRI Database",
f"{get_database_metadata('ESRI.VERSION')} "
f"[{get_database_metadata('ESRI.DATE')}]",
),
(
"IGNF Database",
f"{get_database_metadata('IGNF.VERSION')} "
f"[{get_database_metadata('IGNF.DATE')}]",
),
]
return dict(blob)
def _get_deps_info():
"""Overview of the installed version of main dependencies
Returns
-------
deps_info: dict
version information on relevant Python libraries
"""
deps = ["certifi", "Cython", "setuptools", "pip"]
def get_version(module):
try:
return importlib.metadata.version(module)
except importlib.metadata.PackageNotFoundError:
return None
return {dep: get_version(dep) for dep in deps}
def _print_info_dict(info_dict):
"""Print the information dictionary"""
for key, stat in info_dict.items():
print(f"{key:>10}: {stat}")
def show_versions():
"""
.. versionadded:: 2.2.1
Print useful debugging information
Example
-------
> python -c "import pyproj; pyproj.show_versions()"
"""
print("pyproj info:")
_print_info_dict(_get_proj_info())
print("\nSystem:")
_print_info_dict(_get_sys_info())
print("\nPython deps:")
_print_info_dict(_get_deps_info())
pyproj-3.6.1/pyproj/_sync.pyi 0000664 0000000 0000000 00000000044 14502715416 0016230 0 ustar 00root root 0000000 0000000 def get_proj_endpoint() -> str: ...
pyproj-3.6.1/pyproj/_sync.pyx 0000664 0000000 0000000 00000000423 14502715416 0016250 0 ustar 00root root 0000000 0000000 include "proj.pxi"
from pyproj._datadir cimport PYPROJ_GLOBAL_CONTEXT
def get_proj_endpoint() -> str:
"""
Returns
-------
str:
URL of the endpoint where PROJ grids are stored.
"""
return proj_context_get_url_endpoint(PYPROJ_GLOBAL_CONTEXT)
pyproj-3.6.1/pyproj/_transformer.pxd 0000664 0000000 0000000 00000001141 14502715416 0017607 0 ustar 00root root 0000000 0000000 include "proj.pxi"
from pyproj._crs cimport _CRS, Base
cdef class _TransformerGroup:
cdef PJ_CONTEXT* context
cdef readonly list _transformers
cdef readonly list _unavailable_operations
cdef readonly list _best_available
cdef class _Transformer(Base):
cdef PJ_PROJ_INFO proj_info
cdef readonly _area_of_use
cdef readonly str type_name
cdef readonly tuple _operations
cdef readonly _CRS _source_crs
cdef readonly _CRS _target_crs
@staticmethod
cdef _Transformer _from_pj(
PJ_CONTEXT* context,
PJ *transform_pj,
bint always_xy,
)
pyproj-3.6.1/pyproj/_transformer.pyi 0000664 0000000 0000000 00000007332 14502715416 0017625 0 ustar 00root root 0000000 0000000 import numbers
from array import array
from typing import Any, NamedTuple, Optional, Union
from pyproj._crs import _CRS, AreaOfUse, Base, CoordinateOperation
from pyproj.enums import ProjVersion, TransformDirection
proj_version_str: str
PROJ_VERSION: tuple[int, int, int]
class AreaOfInterest(NamedTuple):
west_lon_degree: float
south_lat_degree: float
east_lon_degree: float
north_lat_degree: float
class Factors(NamedTuple):
meridional_scale: float
parallel_scale: float
areal_scale: float
angular_distortion: float
meridian_parallel_angle: float
meridian_convergence: float
tissot_semimajor: float
tissot_semiminor: float
dx_dlam: float
dx_dphi: float
dy_dlam: float
dy_dphi: float
class _TransformerGroup:
_transformers: Any
_unavailable_operations: list[CoordinateOperation]
_best_available: bool
def __init__(
self,
crs_from: str,
crs_to: str,
always_xy: bool,
area_of_interest: Optional[AreaOfInterest],
authority: Optional[str],
accuracy: Optional[float],
allow_ballpark: bool,
allow_superseded: bool,
) -> None: ...
class _Transformer(Base):
input_geographic: bool
output_geographic: bool
is_pipeline: bool
type_name: str
@property
def id(self) -> str: ...
@property
def description(self) -> str: ...
@property
def definition(self) -> str: ...
@property
def has_inverse(self) -> bool: ...
@property
def accuracy(self) -> float: ...
@property
def area_of_use(self) -> AreaOfUse: ...
@property
def source_crs(self) -> Optional[_CRS]: ...
@property
def target_crs(self) -> Optional[_CRS]: ...
@property
def operations(self) -> Union[tuple[CoordinateOperation], None]: ...
def get_last_used_operation(self) -> _Transformer: ...
@property
def is_network_enabled(self) -> bool: ...
def to_proj4(
self,
version: Union[ProjVersion, str] = ProjVersion.PROJ_5,
pretty: bool = False,
) -> str: ...
@staticmethod
def from_crs(
crs_from: bytes,
crs_to: bytes,
always_xy: bool = False,
area_of_interest: Optional[AreaOfInterest] = None,
authority: Optional[str] = None,
accuracy: Optional[str] = None,
allow_ballpark: Optional[bool] = None,
force_over: bool = False,
only_best: Optional[bool] = None,
) -> "_Transformer": ...
@staticmethod
def from_pipeline(proj_pipeline: bytes) -> "_Transformer": ...
def _transform(
self,
inx: Any,
iny: Any,
inz: Any,
intime: Any,
direction: Union[TransformDirection, str],
radians: bool,
errcheck: bool,
) -> None: ...
def _transform_point(
self,
inx: numbers.Real,
iny: numbers.Real,
inz: numbers.Real,
intime: numbers.Real,
direction: Union[TransformDirection, str],
radians: bool,
errcheck: bool,
) -> None: ...
def _transform_sequence(
self,
stride: int,
inseq: array[float],
switch: bool,
direction: Union[TransformDirection, str],
time_3rd: bool,
radians: bool,
errcheck: bool,
) -> None: ...
def _transform_bounds(
self,
left: float,
bottom: float,
right: float,
top: float,
densify_pts: int = 21,
radians: bool = False,
errcheck: bool = False,
direction: Union[TransformDirection, str] = TransformDirection.FORWARD,
) -> tuple[float, float, float, float]: ...
def _get_factors(
self, longitude: Any, latitude: Any, radians: bool, errcheck: bool
) -> Factors: ...
pyproj-3.6.1/pyproj/_transformer.pyx 0000664 0000000 0000000 00000116076 14502715416 0017652 0 ustar 00root root 0000000 0000000 include "base.pxi"
cimport cython
from cpython.mem cimport PyMem_Free, PyMem_Malloc
import copy
import re
import warnings
from collections import namedtuple
from pyproj._compat cimport cstrencode
from pyproj._crs cimport (
_CRS,
Base,
CoordinateOperation,
_get_concatenated_operations,
_to_proj4,
_to_wkt,
create_area_of_use,
)
from pyproj._datadir cimport (
_clear_proj_error,
_get_proj_error,
pyproj_context_create,
pyproj_context_destroy,
)
from pyproj._datadir import _LOGGER
from pyproj.aoi import AreaOfInterest
from pyproj.enums import ProjVersion, TransformDirection, WktVersion
from pyproj.exceptions import ProjError
# version number string for PROJ
proj_version_str = f"{PROJ_VERSION_MAJOR}.{PROJ_VERSION_MINOR}.{PROJ_VERSION_PATCH}"
PROJ_VERSION = (PROJ_VERSION_MAJOR, PROJ_VERSION_MINOR, PROJ_VERSION_PATCH)
_AUTH_CODE_RE = re.compile(r"(?P\w+)\:(?P\w+)")
IF (CTE_PROJ_VERSION_MAJOR, CTE_PROJ_VERSION_MINOR) >= (9, 1):
cdef extern from "proj.h" nogil:
PJ* proj_trans_get_last_used_operation(PJ *P)
cdef dict _TRANSFORMER_TYPE_MAP = {
PJ_TYPE_UNKNOWN: "Unknown Transformer",
PJ_TYPE_CONVERSION: "Conversion Transformer",
PJ_TYPE_TRANSFORMATION: "Transformation Transformer",
PJ_TYPE_CONCATENATED_OPERATION: "Concatenated Operation Transformer",
PJ_TYPE_OTHER_COORDINATE_OPERATION: "Other Coordinate Operation Transformer",
}
Factors = namedtuple(
"Factors",
[
"meridional_scale",
"parallel_scale",
"areal_scale",
"angular_distortion",
"meridian_parallel_angle",
"meridian_convergence",
"tissot_semimajor",
"tissot_semiminor",
"dx_dlam",
"dx_dphi",
"dy_dlam",
"dy_dphi",
],
)
Factors.__doc__ = """
.. versionadded:: 2.6.0
These are the scaling and angular distortion factors.
See PROJ :c:type:`PJ_FACTORS` documentation.
Parameters
----------
meridional_scale: list[float]
Meridional scale at coordinate.
parallel_scale: list[float]
Parallel scale at coordinate.
areal_scale: list[float]
Areal scale factor at coordinate.
angular_distortion: list[float]
Angular distortion at coordinate.
meridian_parallel_angle: list[float]
Meridian/parallel angle at coordinate.
meridian_convergence: list[float]
Meridian convergence at coordinate. Sometimes also described as *grid declination*.
tissot_semimajor: list[float]
Maximum scale factor.
tissot_semiminor: list[float]
Minimum scale factor.
dx_dlam: list[float]
Partial derivative of coordinate.
dx_dphi: list[float]
Partial derivative of coordinate.
dy_dlam: list[float]
Partial derivative of coordinate.
dy_dphi: list[float]
Partial derivative of coordinate.
"""
cdef PJ_DIRECTION get_pj_direction(object direction) except *:
# optimized lookup to avoid creating a new instance every time
# gh-1205
if not isinstance(direction, TransformDirection):
direction = TransformDirection.create(direction)
# to avoid __hash__ calls from a dictionary lookup,
# we can inline the small number of options for performance
if direction is TransformDirection.FORWARD:
return PJ_FWD
if direction is TransformDirection.INVERSE:
return PJ_INV
if direction is TransformDirection.IDENT:
return PJ_IDENT
raise KeyError(f"{direction} is not a valid TransformDirection")
cdef class _TransformerGroup:
def __cinit__(self):
self.context = NULL
self._transformers = []
self._unavailable_operations = []
self._best_available = True
def __dealloc__(self):
"""destroy projection definition"""
if self.context != NULL:
pyproj_context_destroy(self.context)
def __init__(
self,
_CRS crs_from not None,
_CRS crs_to not None,
bint always_xy,
area_of_interest,
bint allow_ballpark,
str authority,
double accuracy,
bint allow_superseded,
):
"""
From PROJ docs:
The operations are sorted with the most relevant ones first: by
descending area (intersection of the transformation area with the
area of interest, or intersection of the transformation with the
area of use of the CRS), and by increasing accuracy. Operations
with unknown accuracy are sorted last, whatever their area.
"""
self.context = pyproj_context_create()
cdef:
PJ_OPERATION_FACTORY_CONTEXT* operation_factory_context = NULL
PJ_OBJ_LIST * pj_operations = NULL
PJ* pj_transform = NULL
PJ_CONTEXT* context = NULL
const char* c_authority = NULL
int num_operations = 0
int is_instantiable = 0
double west_lon_degree
double south_lat_degree
double east_lon_degree
double north_lat_degree
if authority is not None:
c_authority = authority
try:
operation_factory_context = proj_create_operation_factory_context(
self.context,
c_authority,
)
if area_of_interest is not None:
if not isinstance(area_of_interest, AreaOfInterest):
raise ProjError(
"Area of interest must be of the type "
"pyproj.transformer.AreaOfInterest."
)
west_lon_degree = area_of_interest.west_lon_degree
south_lat_degree = area_of_interest.south_lat_degree
east_lon_degree = area_of_interest.east_lon_degree
north_lat_degree = area_of_interest.north_lat_degree
proj_operation_factory_context_set_area_of_interest(
self.context,
operation_factory_context,
west_lon_degree,
south_lat_degree,
east_lon_degree,
north_lat_degree,
)
if accuracy > 0:
proj_operation_factory_context_set_desired_accuracy(
self.context,
operation_factory_context,
accuracy,
)
proj_operation_factory_context_set_allow_ballpark_transformations(
self.context,
operation_factory_context,
allow_ballpark,
)
proj_operation_factory_context_set_discard_superseded(
self.context,
operation_factory_context,
not allow_superseded,
)
proj_operation_factory_context_set_grid_availability_use(
self.context,
operation_factory_context,
PROJ_GRID_AVAILABILITY_IGNORED,
)
proj_operation_factory_context_set_spatial_criterion(
self.context,
operation_factory_context,
PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION
)
pj_operations = proj_create_operations(
self.context,
crs_from.projobj,
crs_to.projobj,
operation_factory_context,
)
num_operations = proj_list_get_count(pj_operations)
for iii in range(num_operations):
context = pyproj_context_create()
pj_transform = proj_list_get(
context,
pj_operations,
iii,
)
is_instantiable = proj_coordoperation_is_instantiable(
context,
pj_transform,
)
if is_instantiable:
self._transformers.append(
_Transformer._from_pj(
context,
pj_transform,
always_xy,
)
)
else:
coordinate_operation = CoordinateOperation.create(
context,
pj_transform,
)
self._unavailable_operations.append(coordinate_operation)
if iii == 0:
self._best_available = False
warnings.warn(
"Best transformation is not available due to missing "
f"{coordinate_operation.grids[0]!r}"
)
finally:
if operation_factory_context != NULL:
proj_operation_factory_context_destroy(operation_factory_context)
if pj_operations != NULL:
proj_list_destroy(pj_operations)
_clear_proj_error()
cdef PJ* proj_create_crs_to_crs(
PJ_CONTEXT *ctx,
const char *source_crs_str,
const char *target_crs_str,
PJ_AREA *area,
str authority,
str accuracy,
allow_ballpark,
bint force_over,
only_best,
) except NULL:
"""
This is the same as proj_create_crs_to_crs in proj.h
with the options added. It is a hack for stabilily
reasons.
Reference: https://github.com/pyproj4/pyproj/pull/800
"""
cdef PJ *source_crs = proj_create(ctx, source_crs_str)
if source_crs == NULL:
_LOGGER.debug(
"PROJ_DEBUG: proj_create_crs_to_crs: Cannot instantiate source_crs"
)
return NULL
cdef PJ *target_crs = proj_create(ctx, target_crs_str)
if target_crs == NULL:
proj_destroy(source_crs)
_LOGGER.debug(
"PROJ_DEBUG: proj_create_crs_to_crs: Cannot instantiate target_crs"
)
return NULL
cdef:
const char* options[6]
bytes b_authority
bytes b_accuracy
int options_index = 0
int options_init_iii = 0
for options_init_iii in range(6):
options[options_init_iii] = NULL
if authority is not None:
b_authority = cstrencode(f"AUTHORITY={authority}")
options[options_index] = b_authority
options_index += 1
if accuracy is not None:
b_accuracy = cstrencode(f"ACCURACY={accuracy}")
options[options_index] = b_accuracy
options_index += 1
if allow_ballpark is not None:
if not allow_ballpark:
options[options_index] = b"ALLOW_BALLPARK=NO"
options_index += 1
if force_over:
options[options_index] = b"FORCE_OVER=YES"
options_index += 1
if only_best is not None:
IF (CTE_PROJ_VERSION_MAJOR, CTE_PROJ_VERSION_MINOR) >= (9, 2):
if only_best:
options[options_index] = b"ONLY_BEST=YES"
else:
options[options_index] = b"ONLY_BEST=NO"
ELSE:
raise NotImplementedError("only_best requires PROJ 9.2+.")
cdef PJ* transform = proj_create_crs_to_crs_from_pj(
ctx,
source_crs,
target_crs,
area,
options,
)
proj_destroy(source_crs)
proj_destroy(target_crs)
if transform == NULL:
raise ProjError("Error creating Transformer from CRS.")
return transform
cdef class _Transformer(Base):
def __cinit__(self):
self._area_of_use = None
self.type_name = "Unknown Transformer"
self._operations = None
self._source_crs = None
self._target_crs = None
def _initialize_from_projobj(self):
self.proj_info = proj_pj_info(self.projobj)
if self.proj_info.id == NULL:
raise ProjError("Input is not a transformation.")
cdef PJ_TYPE transformer_type = proj_get_type(self.projobj)
self.type_name = _TRANSFORMER_TYPE_MAP[transformer_type]
self._set_base_info()
_clear_proj_error()
@property
def id(self):
return self.proj_info.id
@property
def description(self):
return self.proj_info.description
@property
def definition(self):
return self.proj_info.definition
@property
def has_inverse(self):
return self.proj_info.has_inverse == 1
@property
def accuracy(self):
return self.proj_info.accuracy
@property
def area_of_use(self):
"""
Returns
-------
AreaOfUse:
The area of use object with associated attributes.
"""
if self._area_of_use is not None:
return self._area_of_use
self._area_of_use = create_area_of_use(self.context, self.projobj)
return self._area_of_use
@property
def source_crs(self):
"""
.. versionadded:: 3.3.0
Returns
-------
Optional[_CRS]:
The source CRS of a CoordinateOperation.
"""
if self._source_crs is not None:
return None if self._source_crs is False else self._source_crs
cdef PJ * projobj = proj_get_source_crs(self.context, self.projobj)
_clear_proj_error()
if projobj == NULL:
self._source_crs = False
return None
try:
self._source_crs = _CRS(_to_wkt(
self.context,
projobj,
version=WktVersion.WKT2_2019,
pretty=False,
))
finally:
proj_destroy(projobj)
return self._source_crs
@property
def target_crs(self):
"""
.. versionadded:: 3.3.0
Returns
-------
Optional[_CRS]:
The target CRS of a CoordinateOperation.
"""
if self._target_crs is not None:
return None if self._target_crs is False else self._target_crs
cdef PJ * projobj = proj_get_target_crs(self.context, self.projobj)
_clear_proj_error()
if projobj == NULL:
self._target_crs = False
return None
try:
self._target_crs = _CRS(_to_wkt(
self.context,
projobj,
version=WktVersion.WKT2_2019,
pretty=False,
))
finally:
proj_destroy(projobj)
return self._target_crs
@property
def operations(self):
"""
.. versionadded:: 2.4.0
Returns
-------
tuple[CoordinateOperation]:
The operations in a concatenated operation.
"""
if self._operations is not None:
return self._operations
self._operations = _get_concatenated_operations(self.context, self.projobj)
return self._operations
def get_last_used_operation(self):
IF (CTE_PROJ_VERSION_MAJOR, CTE_PROJ_VERSION_MINOR) >= (9, 1):
cdef PJ* last_used_operation = proj_trans_get_last_used_operation(self.projobj)
if last_used_operation == NULL:
raise ProjError(
"Last used operation not found. "
"This is likely due to not initiating a transform."
)
cdef PJ_CONTEXT* context = NULL
try:
context = pyproj_context_create()
except:
proj_destroy(last_used_operation)
raise
proj_assign_context(last_used_operation, context)
return _Transformer._from_pj(
context,
last_used_operation,
False,
)
ELSE:
raise NotImplementedError("PROJ 9.1+ required to get last used operation.")
@property
def is_network_enabled(self):
"""
.. versionadded:: 3.0.0
Returns
-------
bool:
If the network is enabled.
"""
return proj_context_is_network_enabled(self.context) == 1
def to_proj4(self, version=ProjVersion.PROJ_5, bint pretty=False):
"""
Convert the projection to a PROJ string.
.. versionadded:: 3.1.0
Parameters
----------
version: pyproj.enums.ProjVersion, default=pyproj.enums.ProjVersion.PROJ_5
The version of the PROJ string output.
pretty: bool, default=False
If True, it will set the output to be a multiline string.
Returns
-------
str:
The PROJ string.
"""
return _to_proj4(self.context, self.projobj, version=version, pretty=pretty)
@staticmethod
def from_crs(
const char* crs_from,
const char* crs_to,
bint always_xy=False,
area_of_interest=None,
str authority=None,
str accuracy=None,
allow_ballpark=None,
bint force_over=False,
only_best=None,
):
"""
Create a transformer from CRS objects
"""
cdef:
PJ_AREA *pj_area_of_interest = NULL
double west_lon_degree
double south_lat_degree
double east_lon_degree
double north_lat_degree
_Transformer transformer = _Transformer()
try:
if area_of_interest is not None:
if not isinstance(area_of_interest, AreaOfInterest):
raise ProjError(
"Area of interest must be of the type "
"pyproj.transformer.AreaOfInterest."
)
pj_area_of_interest = proj_area_create()
west_lon_degree = area_of_interest.west_lon_degree
south_lat_degree = area_of_interest.south_lat_degree
east_lon_degree = area_of_interest.east_lon_degree
north_lat_degree = area_of_interest.north_lat_degree
proj_area_set_bbox(
pj_area_of_interest,
west_lon_degree,
south_lat_degree,
east_lon_degree,
north_lat_degree,
)
transformer.context = pyproj_context_create()
transformer.projobj = proj_create_crs_to_crs(
transformer.context,
crs_from,
crs_to,
pj_area_of_interest,
authority=authority,
accuracy=accuracy,
allow_ballpark=allow_ballpark,
force_over=force_over,
only_best=only_best,
)
finally:
if pj_area_of_interest != NULL:
proj_area_destroy(pj_area_of_interest)
transformer._init_from_crs(always_xy)
return transformer
@staticmethod
cdef _Transformer _from_pj(
PJ_CONTEXT* context,
PJ *transform_pj,
bint always_xy,
):
"""
Create a Transformer from a PJ* object
"""
cdef _Transformer transformer = _Transformer()
transformer.context = context
transformer.projobj = transform_pj
if transformer.projobj == NULL:
raise ProjError("Error creating Transformer.")
transformer._init_from_crs(always_xy)
return transformer
@staticmethod
def from_pipeline(const char *proj_pipeline):
"""
Create Transformer from a PROJ pipeline string.
"""
cdef _Transformer transformer = _Transformer()
transformer.context = pyproj_context_create()
auth_match = _AUTH_CODE_RE.match(proj_pipeline.strip())
if auth_match:
# attempt to create coordinate operation from AUTH:CODE
match_data = auth_match.groupdict()
transformer.projobj = proj_create_from_database(
transformer.context,
cstrencode(match_data["authority"]),
cstrencode(match_data["code"]),
PJ_CATEGORY_COORDINATE_OPERATION,
False,
NULL,
)
if transformer.projobj == NULL:
# initialize projection
transformer.projobj = proj_create(
transformer.context,
proj_pipeline,
)
if transformer.projobj is NULL:
raise ProjError(f"Invalid projection {proj_pipeline}.")
transformer._initialize_from_projobj()
return transformer
def _set_always_xy(self):
"""
Setup the transformer so it has the axis order always in xy order.
"""
cdef PJ* always_xy_pj = proj_normalize_for_visualization(
self.context,
self.projobj,
)
proj_destroy(self.projobj)
self.projobj = always_xy_pj
def _init_from_crs(self, bint always_xy):
"""
Finish initializing transformer properties from CRS objects
"""
if always_xy:
self._set_always_xy()
self._initialize_from_projobj()
@cython.boundscheck(False)
@cython.wraparound(False)
def _transform(
self,
object inx,
object iny,
object inz,
object intime,
object direction,
bint radians,
bint errcheck,
):
if self.id == "noop":
return
cdef:
PJ_DIRECTION pj_direction = get_pj_direction(direction)
PyBuffWriteManager xbuff = PyBuffWriteManager(inx)
PyBuffWriteManager ybuff = PyBuffWriteManager(iny)
PyBuffWriteManager zbuff
PyBuffWriteManager tbuff
Py_ssize_t buflenz
Py_ssize_t buflent
double* zz
double* tt
if inz is not None:
zbuff = PyBuffWriteManager(inz)
buflenz = zbuff.len
zz = zbuff.data
else:
buflenz = xbuff.len
zz = NULL
if intime is not None:
tbuff = PyBuffWriteManager(intime)
buflent = tbuff.len
tt = tbuff.data
else:
buflent = xbuff.len
tt = NULL
if not (xbuff.len == ybuff.len == buflenz == buflent):
raise ProjError('x, y, z, and time must be same size if included.')
cdef Py_ssize_t iii
cdef int errno = 0
with nogil:
# degrees to radians
if not radians and proj_angular_input(self.projobj, pj_direction):
for iii in range(xbuff.len):
xbuff.data[iii] = xbuff.data[iii]*_DG2RAD
ybuff.data[iii] = ybuff.data[iii]*_DG2RAD
# radians to degrees
elif radians and proj_degree_input(self.projobj, pj_direction):
for iii in range(xbuff.len):
xbuff.data[iii] = xbuff.data[iii]*_RAD2DG
ybuff.data[iii] = ybuff.data[iii]*_RAD2DG
proj_errno_reset(self.projobj)
proj_trans_generic(
self.projobj,
pj_direction,
xbuff.data, _DOUBLESIZE, xbuff.len,
ybuff.data, _DOUBLESIZE, ybuff.len,
zz, _DOUBLESIZE, xbuff.len,
tt, _DOUBLESIZE, xbuff.len,
)
errno = proj_errno(self.projobj)
if errcheck and errno:
with gil:
raise ProjError(
f"transform error: {proj_context_errno_string(self.context, errno)}"
)
elif errcheck:
with gil:
if _get_proj_error() is not None:
raise ProjError("transform error")
# radians to degrees
if not radians and proj_angular_output(self.projobj, pj_direction):
for iii in range(xbuff.len):
xbuff.data[iii] = xbuff.data[iii]*_RAD2DG
ybuff.data[iii] = ybuff.data[iii]*_RAD2DG
# degrees to radians
elif radians and proj_degree_output(self.projobj, pj_direction):
for iii in range(xbuff.len):
xbuff.data[iii] = xbuff.data[iii]*_DG2RAD
ybuff.data[iii] = ybuff.data[iii]*_DG2RAD
_clear_proj_error()
@cython.boundscheck(False)
@cython.wraparound(False)
def _transform_point(
self,
object inx,
object iny,
object inz,
object intime,
object direction,
bint radians,
bint errcheck,
):
"""
Optimized to transform a single point between two coordinate systems.
"""
cdef:
double coord_x = inx
double coord_y = iny
double coord_z = 0
double coord_t = HUGE_VAL
tuple expected_numeric_types = (int, float)
# We do the type-checking internally here due to automatically
# casting length-1 arrays to float that we don't want to return scalar for.
# Ex: float(np.array([0])) works and we don't want to accept numpy arrays
if not isinstance(inx, expected_numeric_types):
raise TypeError("Scalar input expected for x")
if not isinstance(iny, expected_numeric_types):
raise TypeError("Scalar input expected for y")
if inz is not None:
if not isinstance(inz, expected_numeric_types):
raise TypeError("Scalar input expected for z")
coord_z = inz
if intime is not None:
if not isinstance(intime, expected_numeric_types):
raise TypeError("Scalar input expected for t")
coord_t = intime
cdef tuple return_data
if self.id == "noop":
return_data = (inx, iny)
if inz is not None:
return_data += (inz,)
if intime is not None:
return_data += (intime,)
return return_data
cdef:
PJ_DIRECTION pj_direction = get_pj_direction(direction)
PJ_COORD projxyout
PJ_COORD projxyin = proj_coord(coord_x, coord_y, coord_z, coord_t)
with nogil:
# degrees to radians
if not radians and proj_angular_input(self.projobj, pj_direction):
projxyin.uv.u *= _DG2RAD
projxyin.uv.v *= _DG2RAD
# radians to degrees
elif radians and proj_degree_input(self.projobj, pj_direction):
projxyin.uv.u *= _RAD2DG
projxyin.uv.v *= _RAD2DG
proj_errno_reset(self.projobj)
projxyout = proj_trans(self.projobj, pj_direction, projxyin)
errno = proj_errno(self.projobj)
if errcheck and errno:
with gil:
raise ProjError(
f"transform error: {proj_context_errno_string(self.context, errno)}"
)
elif errcheck:
with gil:
if _clear_proj_error() is not None:
raise ProjError("transform error")
# radians to degrees
if not radians and proj_angular_output(self.projobj, pj_direction):
projxyout.xy.x *= _RAD2DG
projxyout.xy.y *= _RAD2DG
# degrees to radians
elif radians and proj_degree_output(self.projobj, pj_direction):
projxyout.xy.x *= _DG2RAD
projxyout.xy.y *= _DG2RAD
_clear_proj_error()
return_data = (projxyout.xyzt.x, projxyout.xyzt.y)
if inz is not None:
return_data += (projxyout.xyzt.z,)
if intime is not None:
return_data += (projxyout.xyzt.t,)
return return_data
@cython.boundscheck(False)
@cython.wraparound(False)
def _transform_sequence(
self,
Py_ssize_t stride,
object inseq,
bint switch,
object direction,
bint time_3rd,
bint radians,
bint errcheck,
):
# private function to itransform function
if self.id == "noop":
return
cdef:
PJ_DIRECTION pj_direction = get_pj_direction(direction)
double *x
double *y
double *z
double *tt
if stride < 2:
raise ProjError("coordinates must contain at least 2 values")
cdef:
PyBuffWriteManager coordbuff = PyBuffWriteManager(inseq)
Py_ssize_t npts
Py_ssize_t iii
Py_ssize_t jjj
int errno = 0
npts = coordbuff.len // stride
with nogil:
# degrees to radians
if not radians and proj_angular_input(self.projobj, pj_direction):
for iii in range(npts):
jjj = stride * iii
coordbuff.data[jjj] *= _DG2RAD
coordbuff.data[jjj + 1] *= _DG2RAD
# radians to degrees
elif radians and proj_degree_input(self.projobj, pj_direction):
for iii in range(npts):
jjj = stride * iii
coordbuff.data[jjj] *= _RAD2DG
coordbuff.data[jjj + 1] *= _RAD2DG
if not switch:
x = coordbuff.data
y = coordbuff.data + 1
else:
x = coordbuff.data + 1
y = coordbuff.data
# z coordinate
if stride == 4 or (stride == 3 and not time_3rd):
z = coordbuff.data + 2
else:
z = NULL
# time
if stride == 3 and time_3rd:
tt = coordbuff.data + 2
elif stride == 4:
tt = coordbuff.data + 3
else:
tt = NULL
proj_errno_reset(self.projobj)
proj_trans_generic(
self.projobj,
pj_direction,
x, stride*_DOUBLESIZE, npts,
y, stride*_DOUBLESIZE, npts,
z, stride*_DOUBLESIZE, npts,
tt, stride*_DOUBLESIZE, npts,
)
errno = proj_errno(self.projobj)
if errcheck and errno:
with gil:
raise ProjError(
f"itransform error: {proj_context_errno_string(self.context, errno)}"
)
elif errcheck:
with gil:
if _get_proj_error() is not None:
raise ProjError("itransform error")
# radians to degrees
if not radians and proj_angular_output(self.projobj, pj_direction):
for iii in range(npts):
jjj = stride * iii
coordbuff.data[jjj] *= _RAD2DG
coordbuff.data[jjj + 1] *= _RAD2DG
# degrees to radians
elif radians and proj_degree_output(self.projobj, pj_direction):
for iii in range(npts):
jjj = stride * iii
coordbuff.data[jjj] *= _DG2RAD
coordbuff.data[jjj + 1] *= _DG2RAD
_clear_proj_error()
@cython.boundscheck(False)
@cython.wraparound(False)
def _transform_bounds(
self,
double left,
double bottom,
double right,
double top,
int densify_pts,
bint radians,
bint errcheck,
object direction,
):
cdef PJ_DIRECTION pj_direction = get_pj_direction(direction)
if self.id == "noop" or pj_direction == PJ_IDENT:
return (left, bottom, right, top)
cdef:
int errno = 0
bint success = True
double out_left = left
double out_bottom = bottom
double out_right = right
double out_top = top
with nogil:
# degrees to radians
if not radians and proj_angular_input(self.projobj, pj_direction):
left *= _DG2RAD
bottom *= _DG2RAD
right *= _DG2RAD
top *= _DG2RAD
# radians to degrees
elif radians and proj_degree_input(self.projobj, pj_direction):
left *= _RAD2DG
bottom *= _RAD2DG
right *= _RAD2DG
top *= _RAD2DG
proj_errno_reset(self.projobj)
success = proj_trans_bounds(
self.context,
self.projobj,
pj_direction,
left,
bottom,
right,
top,
&out_left,
&out_bottom,
&out_right,
&out_top,
densify_pts,
)
if not success or errcheck:
errno = proj_errno(self.projobj)
if errno:
with gil:
raise ProjError(
"transform bounds error: "
f"{proj_context_errno_string(self.context, errno)}"
)
else:
with gil:
if _get_proj_error() is not None:
raise ProjError("transform bounds error")
# radians to degrees
if not radians and proj_angular_output(self.projobj, pj_direction):
out_left *= _RAD2DG
out_bottom *= _RAD2DG
out_right *= _RAD2DG
out_top *= _RAD2DG
# degrees to radians
elif radians and proj_degree_output(self.projobj, pj_direction):
out_left *= _DG2RAD
out_bottom *= _DG2RAD
out_right *= _DG2RAD
out_top *= _DG2RAD
_clear_proj_error()
return out_left, out_bottom, out_right, out_top
@cython.boundscheck(False)
@cython.wraparound(False)
def _get_factors(self, longitude, latitude, bint radians, bint errcheck):
"""
Calculates the projection factors PJ_FACTORS
Designed to work with Proj class.
Equivalent to `proj -S` command line.
"""
cdef PyBuffWriteManager lonbuff = PyBuffWriteManager(longitude)
cdef PyBuffWriteManager latbuff = PyBuffWriteManager(latitude)
if not lonbuff.len or not (lonbuff.len == latbuff.len):
raise ProjError('longitude and latitude must be same size')
# prepare the factors output
meridional_scale = copy.copy(longitude)
parallel_scale = copy.copy(longitude)
areal_scale = copy.copy(longitude)
angular_distortion = copy.copy(longitude)
meridian_parallel_angle = copy.copy(longitude)
meridian_convergence = copy.copy(longitude)
tissot_semimajor = copy.copy(longitude)
tissot_semiminor = copy.copy(longitude)
dx_dlam = copy.copy(longitude)
dx_dphi = copy.copy(longitude)
dy_dlam = copy.copy(longitude)
dy_dphi = copy.copy(longitude)
cdef:
PyBuffWriteManager meridional_scale_buff = PyBuffWriteManager(
meridional_scale
)
PyBuffWriteManager parallel_scale_buff = PyBuffWriteManager(
parallel_scale
)
PyBuffWriteManager areal_scale_buff = PyBuffWriteManager(areal_scale)
PyBuffWriteManager angular_distortion_buff = PyBuffWriteManager(
angular_distortion
)
PyBuffWriteManager meridian_parallel_angle_buff = PyBuffWriteManager(
meridian_parallel_angle
)
PyBuffWriteManager meridian_convergence_buff = PyBuffWriteManager(
meridian_convergence
)
PyBuffWriteManager tissot_semimajor_buff = PyBuffWriteManager(
tissot_semimajor
)
PyBuffWriteManager tissot_semiminor_buff = PyBuffWriteManager(
tissot_semiminor
)
PyBuffWriteManager dx_dlam_buff = PyBuffWriteManager(dx_dlam)
PyBuffWriteManager dx_dphi_buff = PyBuffWriteManager(dx_dphi)
PyBuffWriteManager dy_dlam_buff = PyBuffWriteManager(dy_dlam)
PyBuffWriteManager dy_dphi_buff = PyBuffWriteManager(dy_dphi)
# calculate the factors
PJ_COORD pj_coord = proj_coord(0, 0, 0, HUGE_VAL)
PJ_FACTORS pj_factors
int errno = 0
bint invalid_coord = 0
Py_ssize_t iii
with nogil:
for iii in range(lonbuff.len):
pj_coord.uv.u = lonbuff.data[iii]
pj_coord.uv.v = latbuff.data[iii]
if not radians:
pj_coord.uv.u *= _DG2RAD
pj_coord.uv.v *= _DG2RAD
# set both to HUGE_VAL if inf or nan
proj_errno_reset(self.projobj)
if pj_coord.uv.v == HUGE_VAL \
or pj_coord.uv.v != pj_coord.uv.v \
or pj_coord.uv.u == HUGE_VAL \
or pj_coord.uv.u != pj_coord.uv.u:
invalid_coord = True
else:
invalid_coord = False
pj_factors = proj_factors(self.projobj, pj_coord)
errno = proj_errno(self.projobj)
if errcheck and errno:
with gil:
raise ProjError(
f"proj error: {proj_context_errno_string(self.context, errno)}"
)
if errno or invalid_coord:
meridional_scale_buff.data[iii] = HUGE_VAL
parallel_scale_buff.data[iii] = HUGE_VAL
areal_scale_buff.data[iii] = HUGE_VAL
angular_distortion_buff.data[iii] = HUGE_VAL
meridian_parallel_angle_buff.data[iii] = HUGE_VAL
meridian_convergence_buff.data[iii] = HUGE_VAL
tissot_semimajor_buff.data[iii] = HUGE_VAL
tissot_semiminor_buff.data[iii] = HUGE_VAL
dx_dlam_buff.data[iii] = HUGE_VAL
dx_dphi_buff.data[iii] = HUGE_VAL
dy_dlam_buff.data[iii] = HUGE_VAL
dy_dphi_buff.data[iii] = HUGE_VAL
else:
meridional_scale_buff.data[iii] = pj_factors.meridional_scale
parallel_scale_buff.data[iii] = pj_factors.parallel_scale
areal_scale_buff.data[iii] = pj_factors.areal_scale
angular_distortion_buff.data[iii] = (
pj_factors.angular_distortion * _RAD2DG
)
meridian_parallel_angle_buff.data[iii] = (
pj_factors.meridian_parallel_angle * _RAD2DG
)
meridian_convergence_buff.data[iii] = (
pj_factors.meridian_convergence * _RAD2DG
)
tissot_semimajor_buff.data[iii] = pj_factors.tissot_semimajor
tissot_semiminor_buff.data[iii] = pj_factors.tissot_semiminor
dx_dlam_buff.data[iii] = pj_factors.dx_dlam
dx_dphi_buff.data[iii] = pj_factors.dx_dphi
dy_dlam_buff.data[iii] = pj_factors.dy_dlam
dy_dphi_buff.data[iii] = pj_factors.dy_dphi
_clear_proj_error()
return Factors(
meridional_scale=meridional_scale,
parallel_scale=parallel_scale,
areal_scale=areal_scale,
angular_distortion=angular_distortion,
meridian_parallel_angle=meridian_parallel_angle,
meridian_convergence=meridian_convergence,
tissot_semimajor=tissot_semimajor,
tissot_semiminor=tissot_semiminor,
dx_dlam=dx_dlam,
dx_dphi=dx_dphi,
dy_dlam=dy_dlam,
dy_dphi=dy_dphi,
)
pyproj-3.6.1/pyproj/aoi.py 0000664 0000000 0000000 00000006560 14502715416 0015525 0 ustar 00root root 0000000 0000000 """
This module contains the structures related to areas of interest.
"""
from dataclasses import dataclass
from typing import NamedTuple, Optional, Union
from pyproj.utils import is_null
@dataclass(frozen=True)
class AreaOfInterest:
"""
.. versionadded:: 2.3.0
This is the area of interest for:
- Transformations
- Querying for CRS data.
"""
#: The west bound in degrees of the area of interest.
west_lon_degree: float
#: The south bound in degrees of the area of interest.
south_lat_degree: float
#: The east bound in degrees of the area of interest.
east_lon_degree: float
#: The north bound in degrees of the area of interest.
north_lat_degree: float
def __post_init__(self):
if (
is_null(self.west_lon_degree)
or is_null(self.south_lat_degree)
or is_null(self.east_lon_degree)
or is_null(self.north_lat_degree)
):
raise ValueError("NaN or None values are not allowed.")
class AreaOfUse(NamedTuple):
"""
.. versionadded:: 2.0.0
Area of Use for CRS, CoordinateOperation, or a Transformer.
"""
#: West bound of area of use.
west: float
#: South bound of area of use.
south: float
#: East bound of area of use.
east: float
#: North bound of area of use.
north: float
#: Name of area of use.
name: Optional[str] = None
@property
def bounds(self) -> tuple[float, float, float, float]:
"""
The bounds of the area of use.
Returns
-------
tuple[float, float, float, float]
west, south, east, and north bounds.
"""
return self.west, self.south, self.east, self.north
def __str__(self) -> str:
return f"- name: {self.name}\n" f"- bounds: {self.bounds}"
@dataclass
class BBox:
"""
Bounding box to check if data intersects/contains other
bounding boxes.
.. versionadded:: 3.0.0
"""
#: West bound of bounding box.
west: float
#: South bound of bounding box.
south: float
#: East bound of bounding box.
east: float
#: North bound of bounding box.
north: float
def __post_init__(self):
if (
is_null(self.west)
or is_null(self.south)
or is_null(self.east)
or is_null(self.north)
):
raise ValueError("NaN or None values are not allowed.")
def intersects(self, other: Union["BBox", AreaOfUse]) -> bool:
"""
Parameters
----------
other: BBox
The other BBox to use to check.
Returns
-------
bool:
True if this BBox intersects the other bbox.
"""
return (
self.west < other.east
and other.west < self.east
and self.south < other.north
and other.south < self.north
)
def contains(self, other: Union["BBox", AreaOfUse]) -> bool:
"""
Parameters
----------
other: Union["BBox", AreaOfUse]
The other BBox to use to check.
Returns
-------
bool:
True if this BBox contains the other bbox.
"""
return (
other.west >= self.west
and other.east <= self.east
and other.south >= self.south
and other.north <= self.north
)
pyproj-3.6.1/pyproj/base.pxi 0000664 0000000 0000000 00000001755 14502715416 0016040 0 ustar 00root root 0000000 0000000 from cpython.ref cimport PyObject
from math import degrees, radians
cdef double _DG2RAD = radians(1.)
cdef double _RAD2DG = degrees(1.)
cdef int _DOUBLESIZE = sizeof(double)
cdef extern from "math.h" nogil:
ctypedef enum:
HUGE_VAL
cdef extern from "Python.h":
ctypedef enum:
PyBUF_WRITABLE
int PyObject_GetBuffer(PyObject *exporter, Py_buffer *view, int flags)
void PyBuffer_Release(Py_buffer *view)
cdef class PyBuffWriteManager:
cdef Py_buffer buffer
cdef double* data
cdef public Py_ssize_t len
def __cinit__(self):
self.data = NULL
def __init__(self, object data):
if PyObject_GetBuffer(data, &self.buffer, PyBUF_WRITABLE) <> 0:
raise BufferError("pyproj had a problem getting the buffer from data.")
self.data = self.buffer.buf
self.len = self.buffer.len // self.buffer.itemsize
def __dealloc__(self):
PyBuffer_Release(&self.buffer)
self.data = NULL
pyproj-3.6.1/pyproj/crs/ 0000775 0000000 0000000 00000000000 14502715416 0015163 5 ustar 00root root 0000000 0000000 pyproj-3.6.1/pyproj/crs/__init__.py 0000664 0000000 0000000 00000001231 14502715416 0017271 0 ustar 00root root 0000000 0000000 """
This module interfaces with PROJ to produce a pythonic interface
to the coordinate reference system (CRS) information through the CRS
class.
"""
from pyproj._crs import ( # noqa: F401 pylint: disable=unused-import
CoordinateOperation,
CoordinateSystem,
Datum,
Ellipsoid,
PrimeMeridian,
is_proj,
is_wkt,
)
from pyproj.crs.crs import ( # noqa: F401 pylint: disable=unused-import
CRS,
BoundCRS,
CompoundCRS,
CustomConstructorCRS,
DerivedGeographicCRS,
GeocentricCRS,
GeographicCRS,
ProjectedCRS,
VerticalCRS,
)
from pyproj.exceptions import CRSError # noqa: F401 pylint: disable=unused-import
pyproj-3.6.1/pyproj/crs/_cf1x8.py 0000664 0000000 0000000 00000064636 14502715416 0016644 0 ustar 00root root 0000000 0000000 """
This module contains mappings necessary to convert from
a CRS to a CF-1.8 compliant projection.
http://cfconventions.org/cf-conventions/cf-conventions.html#appendix-grid-mappings
"""
import warnings
from pyproj._crs import Datum, Ellipsoid, PrimeMeridian
from pyproj.crs.coordinate_operation import (
AlbersEqualAreaConversion,
AzimuthalEquidistantConversion,
GeostationarySatelliteConversion,
HotineObliqueMercatorBConversion,
LambertAzimuthalEqualAreaConversion,
LambertConformalConic1SPConversion,
LambertConformalConic2SPConversion,
LambertCylindricalEqualAreaConversion,
LambertCylindricalEqualAreaScaleConversion,
MercatorAConversion,
MercatorBConversion,
OrthographicConversion,
PolarStereographicAConversion,
PolarStereographicBConversion,
PoleRotationNetCDFCFConversion,
SinusoidalConversion,
StereographicConversion,
TransverseMercatorConversion,
VerticalPerspectiveConversion,
)
from pyproj.crs.datum import CustomDatum, CustomEllipsoid, CustomPrimeMeridian
from pyproj.exceptions import CRSError
def _horizontal_datum_from_params(cf_params):
datum_name = cf_params.get("horizontal_datum_name")
if datum_name and datum_name not in ("undefined", "unknown"):
try:
return Datum.from_name(datum_name)
except CRSError:
pass
# step 1: build ellipsoid
ellipsoid = None
ellipsoid_name = cf_params.get("reference_ellipsoid_name")
try:
ellipsoid = CustomEllipsoid(
name=ellipsoid_name or "undefined",
semi_major_axis=cf_params.get("semi_major_axis"),
semi_minor_axis=cf_params.get("semi_minor_axis"),
inverse_flattening=cf_params.get("inverse_flattening"),
radius=cf_params.get("earth_radius"),
)
except CRSError:
if ellipsoid_name and ellipsoid_name not in ("undefined", "unknown"):
ellipsoid = Ellipsoid.from_name(ellipsoid_name)
# step 2: build prime meridian
prime_meridian = None
prime_meridian_name = cf_params.get("prime_meridian_name")
try:
prime_meridian = CustomPrimeMeridian(
name=prime_meridian_name or "undefined",
longitude=cf_params["longitude_of_prime_meridian"],
)
except KeyError:
if prime_meridian_name and prime_meridian_name not in ("undefined", "unknown"):
prime_meridian = PrimeMeridian.from_name(prime_meridian_name)
# step 3: build datum
if ellipsoid or prime_meridian:
return CustomDatum(
name=datum_name or "undefined",
ellipsoid=ellipsoid or "WGS 84",
prime_meridian=prime_meridian or "Greenwich",
)
return None
def _try_list_if_string(input_str):
"""
Attempt to convert string to list if it is a string
"""
if not isinstance(input_str, str):
return input_str
val_split = input_str.split(",")
if len(val_split) > 1:
return [float(sval.strip()) for sval in val_split]
return input_str
def _get_standard_parallels(standard_parallel):
standard_parallel = _try_list_if_string(standard_parallel)
try:
first_parallel = float(standard_parallel)
second_parallel = None
except TypeError:
first_parallel, second_parallel = standard_parallel
return first_parallel, second_parallel
def _albers_conical_equal_area(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_albers_equal_area
"""
first_parallel, second_parallel = _get_standard_parallels(
cf_params["standard_parallel"]
)
return AlbersEqualAreaConversion(
latitude_first_parallel=first_parallel,
latitude_second_parallel=second_parallel or 0.0,
latitude_false_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_false_origin=cf_params.get("longitude_of_central_meridian", 0.0),
easting_false_origin=cf_params.get("false_easting", 0.0),
northing_false_origin=cf_params.get("false_northing", 0.0),
)
def _azimuthal_equidistant(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#azimuthal-equidistant
"""
return AzimuthalEquidistantConversion(
latitude_natural_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_natural_origin=cf_params.get("longitude_of_projection_origin", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _geostationary(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_geostationary_projection
"""
try:
sweep_angle_axis = cf_params["sweep_angle_axis"]
except KeyError:
sweep_angle_axis = {"x": "y", "y": "x"}[cf_params["fixed_angle_axis"].lower()]
return GeostationarySatelliteConversion(
sweep_angle_axis=sweep_angle_axis,
satellite_height=cf_params["perspective_point_height"],
latitude_natural_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_natural_origin=cf_params.get("longitude_of_projection_origin", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _lambert_azimuthal_equal_area(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#lambert-azimuthal-equal-area
"""
return LambertAzimuthalEqualAreaConversion(
latitude_natural_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_natural_origin=cf_params.get("longitude_of_projection_origin", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _lambert_conformal_conic(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_lambert_conformal
"""
first_parallel, second_parallel = _get_standard_parallels(
cf_params["standard_parallel"]
)
if second_parallel is not None:
return LambertConformalConic2SPConversion(
latitude_first_parallel=first_parallel,
latitude_second_parallel=second_parallel,
latitude_false_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_false_origin=cf_params.get("longitude_of_central_meridian", 0.0),
easting_false_origin=cf_params.get("false_easting", 0.0),
northing_false_origin=cf_params.get("false_northing", 0.0),
)
return LambertConformalConic1SPConversion(
latitude_natural_origin=first_parallel,
longitude_natural_origin=cf_params.get("longitude_of_central_meridian", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _lambert_cylindrical_equal_area(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_lambert_cylindrical_equal_area
"""
if "scale_factor_at_projection_origin" in cf_params:
return LambertCylindricalEqualAreaScaleConversion(
scale_factor_natural_origin=cf_params["scale_factor_at_projection_origin"],
longitude_natural_origin=cf_params.get(
"longitude_of_central_meridian", 0.0
),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
return LambertCylindricalEqualAreaConversion(
latitude_first_parallel=cf_params.get("standard_parallel", 0.0),
longitude_natural_origin=cf_params.get("longitude_of_central_meridian", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _mercator(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_mercator
"""
if "scale_factor_at_projection_origin" in cf_params:
return MercatorAConversion(
latitude_natural_origin=cf_params.get("standard_parallel", 0.0),
longitude_natural_origin=cf_params.get(
"longitude_of_projection_origin", 0.0
),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
scale_factor_natural_origin=cf_params["scale_factor_at_projection_origin"],
)
return MercatorBConversion(
latitude_first_parallel=cf_params.get("standard_parallel", 0.0),
longitude_natural_origin=cf_params.get("longitude_of_projection_origin", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _oblique_mercator(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_oblique_mercator
"""
return HotineObliqueMercatorBConversion(
latitude_projection_centre=cf_params["latitude_of_projection_origin"],
longitude_projection_centre=cf_params["longitude_of_projection_origin"],
azimuth_initial_line=cf_params["azimuth_of_central_line"],
angle_from_rectified_to_skew_grid=0.0,
scale_factor_on_initial_line=cf_params.get(
"scale_factor_at_projection_origin", 1.0
),
easting_projection_centre=cf_params.get("false_easting", 0.0),
northing_projection_centre=cf_params.get("false_northing", 0.0),
)
def _orthographic(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_orthographic
"""
return OrthographicConversion(
latitude_natural_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_natural_origin=cf_params.get("longitude_of_projection_origin", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _polar_stereographic(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#polar-stereographic
"""
if "standard_parallel" in cf_params:
return PolarStereographicBConversion(
latitude_standard_parallel=cf_params["standard_parallel"],
longitude_origin=cf_params["straight_vertical_longitude_from_pole"],
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
return PolarStereographicAConversion(
latitude_natural_origin=cf_params["latitude_of_projection_origin"],
longitude_natural_origin=cf_params["straight_vertical_longitude_from_pole"],
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
scale_factor_natural_origin=cf_params.get(
"scale_factor_at_projection_origin", 1.0
),
)
def _sinusoidal(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_sinusoidal
"""
return SinusoidalConversion(
longitude_natural_origin=cf_params.get("longitude_of_projection_origin", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _stereographic(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_stereographic
"""
return StereographicConversion(
latitude_natural_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_natural_origin=cf_params.get("longitude_of_projection_origin", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
scale_factor_natural_origin=cf_params.get(
"scale_factor_at_projection_origin", 1.0
),
)
def _transverse_mercator(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_transverse_mercator
"""
return TransverseMercatorConversion(
latitude_natural_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_natural_origin=cf_params.get("longitude_of_central_meridian", 0.0),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
scale_factor_natural_origin=cf_params.get(
"scale_factor_at_central_meridian", 1.0
),
)
def _vertical_perspective(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#vertical-perspective
"""
return VerticalPerspectiveConversion(
viewpoint_height=cf_params["perspective_point_height"],
latitude_topocentric_origin=cf_params.get("latitude_of_projection_origin", 0.0),
longitude_topocentric_origin=cf_params.get(
"longitude_of_projection_origin", 0.0
),
false_easting=cf_params.get("false_easting", 0.0),
false_northing=cf_params.get("false_northing", 0.0),
)
def _rotated_latitude_longitude(cf_params):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_rotated_pole
"""
return PoleRotationNetCDFCFConversion(
grid_north_pole_latitude=cf_params["grid_north_pole_latitude"],
grid_north_pole_longitude=cf_params["grid_north_pole_longitude"],
north_pole_grid_longitude=cf_params.get("north_pole_grid_longitude", 0.0),
)
_GRID_MAPPING_NAME_MAP = {
"albers_conical_equal_area": _albers_conical_equal_area,
"azimuthal_equidistant": _azimuthal_equidistant,
"geostationary": _geostationary,
"lambert_azimuthal_equal_area": _lambert_azimuthal_equal_area,
"lambert_conformal_conic": _lambert_conformal_conic,
"lambert_cylindrical_equal_area": _lambert_cylindrical_equal_area,
"mercator": _mercator,
"oblique_mercator": _oblique_mercator,
"orthographic": _orthographic,
"polar_stereographic": _polar_stereographic,
"sinusoidal": _sinusoidal,
"stereographic": _stereographic,
"transverse_mercator": _transverse_mercator,
"vertical_perspective": _vertical_perspective,
}
_GEOGRAPHIC_GRID_MAPPING_NAME_MAP = {
"rotated_latitude_longitude": _rotated_latitude_longitude
}
def _to_dict(operation):
param_dict = {}
for param in operation.params:
param_dict[param.name.lower().replace(" ", "_")] = param.value
return param_dict
def _albers_conical_equal_area__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_albers_equal_area
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "albers_conical_equal_area",
"standard_parallel": (
params["latitude_of_1st_standard_parallel"],
params["latitude_of_2nd_standard_parallel"],
),
"latitude_of_projection_origin": params["latitude_of_false_origin"],
"longitude_of_central_meridian": params["longitude_of_false_origin"],
"false_easting": params["easting_at_false_origin"],
"false_northing": params["northing_at_false_origin"],
}
def _azimuthal_equidistant__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#azimuthal-equidistant
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "azimuthal_equidistant",
"latitude_of_projection_origin": params["latitude_of_natural_origin"],
"longitude_of_projection_origin": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _geostationary__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_geostationary_projection
"""
params = _to_dict(conversion)
sweep_angle_axis = "y"
if conversion.method_name.lower().replace(" ", "_").endswith("(sweep_x)"):
sweep_angle_axis = "x"
return {
"grid_mapping_name": "geostationary",
"sweep_angle_axis": sweep_angle_axis,
"perspective_point_height": params["satellite_height"],
# geostationary satellites orbit around equator
# so latitude_of_natural_origin is often left off and assumed to be 0.0
"latitude_of_projection_origin": params.get("latitude_of_natural_origin", 0.0),
"longitude_of_projection_origin": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _lambert_azimuthal_equal_area__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#lambert-azimuthal-equal-area
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "lambert_azimuthal_equal_area",
"latitude_of_projection_origin": params["latitude_of_natural_origin"],
"longitude_of_projection_origin": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _lambert_conformal_conic__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_lambert_conformal
"""
params = _to_dict(conversion)
if conversion.method_name.lower().endswith("(2sp)"):
return {
"grid_mapping_name": "lambert_conformal_conic",
"standard_parallel": (
params["latitude_of_1st_standard_parallel"],
params["latitude_of_2nd_standard_parallel"],
),
"latitude_of_projection_origin": params["latitude_of_false_origin"],
"longitude_of_central_meridian": params["longitude_of_false_origin"],
"false_easting": params["easting_at_false_origin"],
"false_northing": params["northing_at_false_origin"],
}
return {
"grid_mapping_name": "lambert_conformal_conic",
"standard_parallel": params["latitude_of_natural_origin"],
"longitude_of_central_meridian": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _lambert_cylindrical_equal_area__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_lambert_cylindrical_equal_area
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "lambert_cylindrical_equal_area",
"standard_parallel": params["latitude_of_1st_standard_parallel"],
"longitude_of_central_meridian": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _mercator__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_mercator
"""
params = _to_dict(conversion)
if conversion.method_name.lower().replace(" ", "_").endswith("(variant_a)"):
return {
"grid_mapping_name": "mercator",
"standard_parallel": params["latitude_of_natural_origin"],
"longitude_of_projection_origin": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
"scale_factor_at_projection_origin": params[
"scale_factor_at_natural_origin"
],
}
return {
"grid_mapping_name": "mercator",
"standard_parallel": params["latitude_of_1st_standard_parallel"],
"longitude_of_projection_origin": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _oblique_mercator__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_oblique_mercator
"""
params = _to_dict(conversion)
if params["angle_from_rectified_to_skew_grid"] != 0:
warnings.warn(
"angle from rectified to skew grid parameter lost in conversion to CF"
)
return {
"grid_mapping_name": "oblique_mercator",
"latitude_of_projection_origin": params["latitude_of_projection_centre"],
"longitude_of_projection_origin": params["longitude_of_projection_centre"],
"azimuth_of_central_line": params["azimuth_of_initial_line"],
"scale_factor_at_projection_origin": params["scale_factor_on_initial_line"],
"false_easting": params["easting_at_projection_centre"],
"false_northing": params["northing_at_projection_centre"],
}
def _orthographic__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_orthographic
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "orthographic",
"latitude_of_projection_origin": params["latitude_of_natural_origin"],
"longitude_of_projection_origin": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _polar_stereographic__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#polar-stereographic
"""
params = _to_dict(conversion)
if conversion.method_name.lower().endswith("(variant b)"):
return {
"grid_mapping_name": "polar_stereographic",
"standard_parallel": params["latitude_of_standard_parallel"],
"straight_vertical_longitude_from_pole": params["longitude_of_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
return {
"grid_mapping_name": "polar_stereographic",
"latitude_of_projection_origin": params["latitude_of_natural_origin"],
"straight_vertical_longitude_from_pole": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
"scale_factor_at_projection_origin": params["scale_factor_at_natural_origin"],
}
def _sinusoidal__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_sinusoidal
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "sinusoidal",
"longitude_of_projection_origin": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _stereographic__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_stereographic
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "stereographic",
"latitude_of_projection_origin": params["latitude_of_natural_origin"],
"longitude_of_projection_origin": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
"scale_factor_at_projection_origin": params["scale_factor_at_natural_origin"],
}
def _transverse_mercator__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_transverse_mercator
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": params["latitude_of_natural_origin"],
"longitude_of_central_meridian": params["longitude_of_natural_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
"scale_factor_at_central_meridian": params["scale_factor_at_natural_origin"],
}
def _vertical_perspective__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#vertical-perspective
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "vertical_perspective",
"perspective_point_height": params["viewpoint_height"],
"latitude_of_projection_origin": params["latitude_of_topocentric_origin"],
"longitude_of_projection_origin": params["longitude_of_topocentric_origin"],
"false_easting": params["false_easting"],
"false_northing": params["false_northing"],
}
def _rotated_latitude_longitude__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_rotated_pole
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "rotated_latitude_longitude",
"grid_north_pole_latitude": params["o_lat_p"],
# https://github.com/pyproj4/pyproj/issues/927
"grid_north_pole_longitude": params["lon_0"] - 180,
"north_pole_grid_longitude": params["o_lon_p"],
}
def _pole_rotation_netcdf__to_cf(conversion):
"""
http://cfconventions.org/cf-conventions/cf-conventions.html#_rotated_pole
https://github.com/OSGeo/PROJ/pull/2835
"""
params = _to_dict(conversion)
return {
"grid_mapping_name": "rotated_latitude_longitude",
"grid_north_pole_latitude": params[
"grid_north_pole_latitude_(netcdf_cf_convention)"
],
"grid_north_pole_longitude": params[
"grid_north_pole_longitude_(netcdf_cf_convention)"
],
"north_pole_grid_longitude": params[
"north_pole_grid_longitude_(netcdf_cf_convention)"
],
}
_INVERSE_GRID_MAPPING_NAME_MAP = {
"albers_equal_area": _albers_conical_equal_area__to_cf,
"modified_azimuthal_equidistant": _azimuthal_equidistant__to_cf,
"geostationary_satellite_(sweep_x)": _geostationary__to_cf,
"geostationary_satellite_(sweep_y)": _geostationary__to_cf,
"lambert_azimuthal_equal_area": _lambert_azimuthal_equal_area__to_cf,
"lambert_conic_conformal_(2sp)": _lambert_conformal_conic__to_cf,
"lambert_conic_conformal_(1sp)": _lambert_conformal_conic__to_cf,
"lambert_cylindrical_equal_area": _lambert_cylindrical_equal_area__to_cf,
"mercator_(variant_a)": _mercator__to_cf,
"mercator_(variant_b)": _mercator__to_cf,
"hotine_oblique_mercator_(variant_b)": _oblique_mercator__to_cf,
"orthographic": _orthographic__to_cf,
"polar_stereographic_(variant_a)": _polar_stereographic__to_cf,
"polar_stereographic_(variant_b)": _polar_stereographic__to_cf,
"sinusoidal": _sinusoidal__to_cf,
"stereographic": _stereographic__to_cf,
"transverse_mercator": _transverse_mercator__to_cf,
"vertical_perspective": _vertical_perspective__to_cf,
}
_INVERSE_GEOGRAPHIC_GRID_MAPPING_NAME_MAP = {
"proj ob_tran o_proj=longlat": _rotated_latitude_longitude__to_cf,
"proj ob_tran o_proj=lonlat": _rotated_latitude_longitude__to_cf,
"proj ob_tran o_proj=latlon": _rotated_latitude_longitude__to_cf,
"proj ob_tran o_proj=latlong": _rotated_latitude_longitude__to_cf,
"pole rotation (netcdf cf convention)": _pole_rotation_netcdf__to_cf,
}
pyproj-3.6.1/pyproj/crs/coordinate_operation.py 0000664 0000000 0000000 00000161026 14502715416 0021752 0 ustar 00root root 0000000 0000000 """
This module is for building operations to be used when
building a CRS.
:ref:`operations`
"""
# pylint: disable=too-many-lines
import warnings
from typing import Any
from pyproj._crs import CoordinateOperation
from pyproj.exceptions import CRSError
class AlbersEqualAreaConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Albers Equal Area Conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_first_parallel: float,
latitude_second_parallel: float,
latitude_false_origin: float = 0.0,
longitude_false_origin: float = 0.0,
easting_false_origin: float = 0.0,
northing_false_origin: float = 0.0,
):
"""
Parameters
----------
latitude_first_parallel: float
First standard parallel (lat_1).
latitude_second_parallel: float
Second standard parallel (lat_2).
latitude_false_origin: float, default=0.0
Latitude of projection center (lat_0).
longitude_false_origin: float, default=0.0
Longitude of projection center (lon_0).
easting_false_origin: float, default=0.0
False easting (x_0).
northing_false_origin: float, default=0.0
False northing (y_0).
"""
aea_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Albers Equal Area",
"id": {"authority": "EPSG", "code": 9822},
},
"parameters": [
{
"name": "Latitude of false origin",
"value": latitude_false_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8821},
},
{
"name": "Longitude of false origin",
"value": longitude_false_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8822},
},
{
"name": "Latitude of 1st standard parallel",
"value": latitude_first_parallel,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8823},
},
{
"name": "Latitude of 2nd standard parallel",
"value": latitude_second_parallel,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8824},
},
{
"name": "Easting at false origin",
"value": easting_false_origin,
"unit": {
"type": "LinearUnit",
"name": "Metre",
"conversion_factor": 1,
},
"id": {"authority": "EPSG", "code": 8826},
},
{
"name": "Northing at false origin",
"value": northing_false_origin,
"unit": {
"type": "LinearUnit",
"name": "Metre",
"conversion_factor": 1,
},
"id": {"authority": "EPSG", "code": 8827},
},
],
}
return cls.from_json_dict(aea_json)
class AzimuthalEquidistantConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0 AzumuthalEquidistantConversion
.. versionadded:: 3.2.0 AzimuthalEquidistantConversion
Class for constructing the Modified Azimuthal Equidistant conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
latitude_natural_origin: float, default=0.0
Latitude of projection center (lat_0).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
aeqd_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Modified Azimuthal Equidistant",
"id": {"authority": "EPSG", "code": 9832},
},
"parameters": [
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(aeqd_json)
class GeostationarySatelliteConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Geostationary Satellite conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
sweep_angle_axis: str,
satellite_height: float,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
sweep_angle_axis: str
Sweep angle axis of the viewing instrument. Valid options are “X” and “Y”.
satellite_height: float
Satellite height.
latitude_natural_origin: float, default=0.0
Latitude of projection center (lat_0).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
sweep_angle_axis = sweep_angle_axis.strip().upper()
valid_sweep_axis = ("X", "Y")
if sweep_angle_axis not in valid_sweep_axis:
raise CRSError(f"sweep_angle_axis only supports {valid_sweep_axis}")
if latitude_natural_origin != 0:
warnings.warn(
"The latitude of natural origin (lat_0) is not used "
"within PROJ. It is only supported for exporting to "
"the WKT or PROJ JSON formats."
)
geos_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {"name": f"Geostationary Satellite (Sweep {sweep_angle_axis})"},
"parameters": [
{
"name": "Satellite height",
"value": satellite_height,
"unit": "metre",
},
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(geos_json)
class LambertAzimuthalEqualAreaConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0 LambertAzumuthalEqualAreaConversion
.. versionadded:: 3.2.0 LambertAzimuthalEqualAreaConversion
Class for constructing the Lambert Azimuthal Equal Area conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
latitude_natural_origin: float, default=0.0
Latitude of projection center (lat_0).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
laea_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Lambert Azimuthal Equal Area",
"id": {"authority": "EPSG", "code": 9820},
},
"parameters": [
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(laea_json)
class LambertConformalConic2SPConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Lambert Conformal Conic 2SP conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_first_parallel: float,
latitude_second_parallel: float,
latitude_false_origin: float = 0.0,
longitude_false_origin: float = 0.0,
easting_false_origin: float = 0.0,
northing_false_origin: float = 0.0,
):
"""
Parameters
----------
latitude_first_parallel: float
Latitude of 1st standard parallel (lat_1).
latitude_second_parallel: float
Latitude of 2nd standard parallel (lat_2).
latitude_false_origin: float, default=0.0
Latitude of projection center (lat_0).
longitude_false_origin: float, default=0.0
Longitude of projection center (lon_0).
easting_false_origin: float, default=0.0
False easting (x_0).
northing_false_origin: float, default=0.0
False northing (y_0).
"""
lcc_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Lambert Conic Conformal (2SP)",
"id": {"authority": "EPSG", "code": 9802},
},
"parameters": [
{
"name": "Latitude of 1st standard parallel",
"value": latitude_first_parallel,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8823},
},
{
"name": "Latitude of 2nd standard parallel",
"value": latitude_second_parallel,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8824},
},
{
"name": "Latitude of false origin",
"value": latitude_false_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8821},
},
{
"name": "Longitude of false origin",
"value": longitude_false_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8822},
},
{
"name": "Easting at false origin",
"value": easting_false_origin,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8826},
},
{
"name": "Northing at false origin",
"value": northing_false_origin,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8827},
},
],
}
return cls.from_json_dict(lcc_json)
class LambertConformalConic1SPConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Lambert Conformal Conic 1SP conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
scale_factor_natural_origin: float = 1.0,
):
"""
Parameters
----------
latitude_natural_origin: float, default=0.0
Latitude of projection center (lat_0).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
scale_factor_natural_origin: float, default=1.0
Scale factor at natural origin (k_0).
"""
lcc_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Lambert Conic Conformal (1SP)",
"id": {"authority": "EPSG", "code": 9801},
},
"parameters": [
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "Scale factor at natural origin",
"value": scale_factor_natural_origin,
"unit": "unity",
"id": {"authority": "EPSG", "code": 8805},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(lcc_json)
class LambertCylindricalEqualAreaConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Lambert Cylindrical Equal Area conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_first_parallel: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
latitude_first_parallel: float, default=0.0
Latitude of 1st standard parallel (lat_ts).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
cea_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Lambert Cylindrical Equal Area",
"id": {"authority": "EPSG", "code": 9835},
},
"parameters": [
{
"name": "Latitude of 1st standard parallel",
"value": latitude_first_parallel,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8823},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(cea_json)
class LambertCylindricalEqualAreaScaleConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Lambert Cylindrical Equal Area conversion.
This version uses the scale factor and differs from the official version.
The scale factor will be converted to the Latitude of 1st standard parallel (lat_ts)
when exporting to WKT in PROJ>=7.0.0. Previous version will export it as a
PROJ-based coordinate operation in the WKT.
:ref:`PROJ docs `
"""
def __new__(
cls,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
scale_factor_natural_origin: float = 1.0,
):
"""
Parameters
----------
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
scale_factor_natural_origin: float, default=1.0
Scale factor at natural origin (k or k_0).
"""
# pylint: disable=import-outside-toplevel
from pyproj.crs import CRS
# hack due to: https://github.com/OSGeo/PROJ/issues/1881
proj_string = (
"+proj=cea "
f"+lon_0={longitude_natural_origin} "
f"+x_0={false_easting} "
f"+y_0={false_northing} "
f"+k_0={scale_factor_natural_origin}"
)
return cls.from_json(
CRS(proj_string).coordinate_operation.to_json() # type: ignore
)
class MercatorAConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Mercator (variant A) conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
scale_factor_natural_origin: float = 1.0,
):
"""
Parameters
----------
latitude_natural_origin: float, default=0.0
Latitude of natural origin (lat_0). Must be 0 by `this conversion's
definition
`_.
longitude_natural_origin: float, default=0.0
Longitude of natural origin (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
scale_factor_natural_origin: float, default=1.0
Scale factor at natural origin (k or k_0).
"""
if latitude_natural_origin != 0:
raise CRSError(
"This conversion is defined for only latitude_natural_origin = 0."
)
merc_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Mercator (variant A)",
"id": {"authority": "EPSG", "code": 9804},
},
"parameters": [
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "Scale factor at natural origin",
"value": scale_factor_natural_origin,
"unit": "unity",
"id": {"authority": "EPSG", "code": 8805},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(merc_json)
class MercatorBConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Mercator (variant B) conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_first_parallel: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
latitude_first_parallel: float, default=0.0
Latitude of 1st standard parallel (lat_ts).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
merc_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Mercator (variant B)",
"id": {"authority": "EPSG", "code": 9805},
},
"parameters": [
{
"name": "Latitude of 1st standard parallel",
"value": latitude_first_parallel,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8823},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(merc_json)
class HotineObliqueMercatorBConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Hotine Oblique Mercator (variant B) conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_projection_centre: float,
longitude_projection_centre: float,
azimuth_initial_line: float,
angle_from_rectified_to_skew_grid: float,
scale_factor_on_initial_line: float = 1.0,
easting_projection_centre: float = 0.0,
northing_projection_centre: float = 0.0,
):
"""
Parameters
----------
latitude_projection_centre: float
Latitude of projection centre (lat_0).
longitude_projection_centre: float
Longitude of projection centre (lonc).
azimuth_initial_line: float
Azimuth of initial line (alpha).
angle_from_rectified_to_skew_grid: float
Angle from Rectified to Skew Grid (gamma).
scale_factor_on_initial_line: float, default=1.0
Scale factor on initial line (k or k_0).
easting_projection_centre: float, default=0.0
Easting at projection centre (x_0).
northing_projection_centre: float, default=0.0
Northing at projection centre (y_0).
"""
omerc_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Hotine Oblique Mercator (variant B)",
"id": {"authority": "EPSG", "code": 9815},
},
"parameters": [
{
"name": "Latitude of projection centre",
"value": latitude_projection_centre,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8811},
},
{
"name": "Longitude of projection centre",
"value": longitude_projection_centre,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8812},
},
{
"name": "Azimuth of initial line",
"value": azimuth_initial_line,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8813},
},
{
"name": "Angle from Rectified to Skew Grid",
"value": angle_from_rectified_to_skew_grid,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8814},
},
{
"name": "Scale factor on initial line",
"value": scale_factor_on_initial_line,
"unit": "unity",
"id": {"authority": "EPSG", "code": 8815},
},
{
"name": "Easting at projection centre",
"value": easting_projection_centre,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8816},
},
{
"name": "Northing at projection centre",
"value": northing_projection_centre,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8817},
},
],
}
return cls.from_json_dict(omerc_json)
class OrthographicConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Orthographic conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
latitude_natural_origin: float, default=0.0
Latitude of projection center (lat_0).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
ortho_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Orthographic",
"id": {"authority": "EPSG", "code": 9840},
},
"parameters": [
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(ortho_json)
class PolarStereographicAConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Polar Stereographic A conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_natural_origin: float,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
scale_factor_natural_origin: float = 1.0,
):
"""
Parameters
----------
latitude_natural_origin: float
Latitude of natural origin (lat_0). Either +90 or -90.
longitude_natural_origin: float, default=0.0
Longitude of natural origin (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
scale_factor_natural_origin: float, default=0.0
Scale factor at natural origin (k or k_0).
"""
stere_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Polar Stereographic (variant A)",
"id": {"authority": "EPSG", "code": 9810},
},
"parameters": [
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "Scale factor at natural origin",
"value": scale_factor_natural_origin,
"unit": "unity",
"id": {"authority": "EPSG", "code": 8805},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(stere_json)
class PolarStereographicBConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Polar Stereographic B conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_standard_parallel: float = 0.0,
longitude_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
latitude_standard_parallel: float, default=0.0
Latitude of standard parallel (lat_ts).
longitude_origin: float, default=0.0
Longitude of origin (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
stere_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Polar Stereographic (variant B)",
"id": {"authority": "EPSG", "code": 9829},
},
"parameters": [
{
"name": "Latitude of standard parallel",
"value": latitude_standard_parallel,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8832},
},
{
"name": "Longitude of origin",
"value": longitude_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8833},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(stere_json)
class SinusoidalConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Sinusoidal conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
sinu_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {"name": "Sinusoidal"},
"parameters": [
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(sinu_json)
class StereographicConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Stereographic conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
scale_factor_natural_origin: float = 1.0,
):
"""
Parameters
----------
latitude_natural_origin: float, default=0.0
Latitude of natural origin (lat_0).
longitude_natural_origin: float, default=0.0
Longitude of natural origin (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
scale_factor_natural_origin: float, default=1.0
Scale factor at natural origin (k or k_0).
"""
stere_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {"name": "Stereographic"},
"parameters": [
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "Scale factor at natural origin",
"value": scale_factor_natural_origin,
"unit": "unity",
"id": {"authority": "EPSG", "code": 8805},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(stere_json)
class UTMConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the UTM conversion.
:ref:`PROJ docs `
"""
def __new__(cls, zone: str, hemisphere: str = "N"):
"""
Parameters
----------
zone: int
UTM Zone between 1-60.
hemisphere: str, default="N"
Either N for North or S for South.
"""
return cls.from_name(f"UTM zone {zone}{hemisphere}")
class TransverseMercatorConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Transverse Mercator conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
scale_factor_natural_origin: float = 1.0,
):
"""
Parameters
----------
latitude_natural_origin: float, default=0.0
Latitude of projection center (lat_0).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
scale_factor_natural_origin: float, default=1.0
Scale factor at natural origin (k or k_0).
"""
tmerc_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Transverse Mercator",
"id": {"authority": "EPSG", "code": 9807},
},
"parameters": [
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "Scale factor at natural origin",
"value": scale_factor_natural_origin,
"unit": "unity",
"id": {"authority": "EPSG", "code": 8805},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(tmerc_json)
class VerticalPerspectiveConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Vetical Perspective conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
viewpoint_height: float,
latitude_topocentric_origin: float = 0.0,
longitude_topocentric_origin: float = 0.0,
ellipsoidal_height_topocentric_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
viewpoint_height: float
Viewpoint height (h).
latitude_topocentric_origin: float, default=0.0
Latitude of topocentric origin (lat_0).
longitude_topocentric_origin: float, default=0.0
Longitude of topocentric origin (lon_0).
ellipsoidal_height_topocentric_origin: float, default=0.0
Ellipsoidal height of topocentric origin.
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
nsper_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Vertical Perspective",
"id": {"authority": "EPSG", "code": 9838},
},
"parameters": [
{
"name": "Latitude of topocentric origin",
"value": latitude_topocentric_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8834},
},
{
"name": "Longitude of topocentric origin",
"value": longitude_topocentric_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8835},
},
{
"name": "Ellipsoidal height of topocentric origin",
"value": ellipsoidal_height_topocentric_origin,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8836},
},
{
"name": "Viewpoint height",
"value": viewpoint_height,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8840},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(nsper_json)
class RotatedLatitudeLongitudeConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Rotated Latitude Longitude conversion.
:ref:`PROJ docs `
"""
def __new__(cls, o_lat_p: float, o_lon_p: float, lon_0: float = 0.0):
"""
Parameters
----------
o_lat_p: float
Latitude of the North pole of the unrotated source CRS,
expressed in the rotated geographic CRS.
o_lon_p: float
Longitude of the North pole of the unrotated source CRS,
expressed in the rotated geographic CRS.
lon_0: float, default=0.0
Longitude of projection center.
"""
rot_latlon_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {"name": "PROJ ob_tran o_proj=longlat"},
"parameters": [
{"name": "o_lat_p", "value": o_lat_p, "unit": "degree"},
{"name": "o_lon_p", "value": o_lon_p, "unit": "degree"},
{"name": "lon_0", "value": lon_0, "unit": "degree"},
],
}
return cls.from_json_dict(rot_latlon_json)
class PoleRotationNetCDFCFConversion(CoordinateOperation):
"""
.. versionadded:: 3.3.0
Class for constructing the Pole rotation (netCDF CF convention) conversion.
http://cfconventions.org/cf-conventions/cf-conventions.html#_rotated_pole
:ref:`PROJ docs `
"""
def __new__(
cls,
grid_north_pole_latitude: float,
grid_north_pole_longitude: float,
north_pole_grid_longitude: float = 0.0,
):
"""
Parameters
----------
grid_north_pole_latitude: float
Latitude of the North pole of the unrotated source CRS,
expressed in the rotated geographic CRS (o_lat_p)
grid_north_pole_longitude: float
Longitude of projection center (lon_0 - 180).
north_pole_grid_longitude: float, default=0.0
Longitude of the North pole of the unrotated source CRS,
expressed in the rotated geographic CRS (o_lon_p).
"""
rot_latlon_json = {
"$schema": "https://proj.org/schemas/v0.4/projjson.schema.json",
"type": "Conversion",
"name": "Pole rotation (netCDF CF convention)",
"method": {"name": "Pole rotation (netCDF CF convention)"},
"parameters": [
{
"name": "Grid north pole latitude (netCDF CF convention)",
"value": grid_north_pole_latitude,
"unit": "degree",
},
{
"name": "Grid north pole longitude (netCDF CF convention)",
"value": grid_north_pole_longitude,
"unit": "degree",
},
{
"name": "North pole grid longitude (netCDF CF convention)",
"value": north_pole_grid_longitude,
"unit": "degree",
},
],
}
return cls.from_json_dict(rot_latlon_json)
class EquidistantCylindricalConversion(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the Equidistant Cylintrical (Plate Carrée) conversion.
:ref:`PROJ docs `
"""
def __new__(
cls,
latitude_first_parallel: float = 0.0,
latitude_natural_origin: float = 0.0,
longitude_natural_origin: float = 0.0,
false_easting: float = 0.0,
false_northing: float = 0.0,
):
"""
Parameters
----------
latitude_first_parallel: float, default=0.0
Latitude of 1st standard parallel (lat_ts).
latitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
longitude_natural_origin: float, default=0.0
Longitude of projection center (lon_0).
false_easting: float, default=0.0
False easting (x_0).
false_northing: float, default=0.0
False northing (y_0).
"""
eqc_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Conversion",
"name": "unknown",
"method": {
"name": "Equidistant Cylindrical",
"id": {"authority": "EPSG", "code": 1028},
},
"parameters": [
{
"name": "Latitude of 1st standard parallel",
"value": latitude_first_parallel,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8823},
},
{
"name": "Latitude of natural origin",
"value": latitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8801},
},
{
"name": "Longitude of natural origin",
"value": longitude_natural_origin,
"unit": "degree",
"id": {"authority": "EPSG", "code": 8802},
},
{
"name": "False easting",
"value": false_easting,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8806},
},
{
"name": "False northing",
"value": false_northing,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8807},
},
],
}
return cls.from_json_dict(eqc_json)
# Add an alias for PlateCarree
PlateCarreeConversion = EquidistantCylindricalConversion
class ToWGS84Transformation(CoordinateOperation):
"""
.. versionadded:: 2.5.0
Class for constructing the ToWGS84 Transformation.
"""
def __new__(
cls,
source_crs: Any,
x_axis_translation: float = 0,
y_axis_translation: float = 0,
z_axis_translation: float = 0,
x_axis_rotation: float = 0,
y_axis_rotation: float = 0,
z_axis_rotation: float = 0,
scale_difference: float = 0,
):
"""
Parameters
----------
source_crs: Any
Input to create the Source CRS.
x_axis_translation: float, default=0.0
X-axis translation.
y_axis_translation: float, default=0.0
Y-axis translation.
z_axis_translation: float, default=0.0
Z-axis translation.
x_axis_rotation: float, default=0.0
X-axis rotation.
y_axis_rotation: float, default=0.0
Y-axis rotation.
z_axis_rotation: float, default=0.0
Z-axis rotation.
scale_difference: float, default=0.0
Scale difference.
"""
# pylint: disable=import-outside-toplevel
from pyproj.crs import CRS
towgs84_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Transformation",
"name": "Transformation from unknown to WGS84",
"source_crs": CRS.from_user_input(source_crs).to_json_dict(),
"target_crs": {
"type": "GeographicCRS",
"name": "WGS 84",
"datum": {
"type": "GeodeticReferenceFrame",
"name": "World Geodetic System 1984",
"ellipsoid": {
"name": "WGS 84",
"semi_major_axis": 6378137,
"inverse_flattening": 298.257223563,
},
},
"coordinate_system": {
"subtype": "ellipsoidal",
"axis": [
{
"name": "Latitude",
"abbreviation": "lat",
"direction": "north",
"unit": "degree",
},
{
"name": "Longitude",
"abbreviation": "lon",
"direction": "east",
"unit": "degree",
},
],
},
"id": {"authority": "EPSG", "code": 4326},
},
"method": {
"name": "Position Vector transformation (geog2D domain)",
"id": {"authority": "EPSG", "code": 9606},
},
"parameters": [
{
"name": "X-axis translation",
"value": x_axis_translation,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8605},
},
{
"name": "Y-axis translation",
"value": y_axis_translation,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8606},
},
{
"name": "Z-axis translation",
"value": z_axis_translation,
"unit": "metre",
"id": {"authority": "EPSG", "code": 8607},
},
{
"name": "X-axis rotation",
"value": x_axis_rotation,
"unit": {
"type": "AngularUnit",
"name": "arc-second",
"conversion_factor": 4.84813681109536e-06,
},
"id": {"authority": "EPSG", "code": 8608},
},
{
"name": "Y-axis rotation",
"value": y_axis_rotation,
"unit": {
"type": "AngularUnit",
"name": "arc-second",
"conversion_factor": 4.84813681109536e-06,
},
"id": {"authority": "EPSG", "code": 8609},
},
{
"name": "Z-axis rotation",
"value": z_axis_rotation,
"unit": {
"type": "AngularUnit",
"name": "arc-second",
"conversion_factor": 4.84813681109536e-06,
},
"id": {"authority": "EPSG", "code": 8610},
},
{
"name": "Scale difference",
"value": scale_difference,
"unit": {
"type": "ScaleUnit",
"name": "parts per million",
"conversion_factor": 1e-06,
},
"id": {"authority": "EPSG", "code": 8611},
},
],
}
return cls.from_json_dict(towgs84_json)
pyproj-3.6.1/pyproj/crs/coordinate_system.py 0000664 0000000 0000000 00000023554 14502715416 0021301 0 ustar 00root root 0000000 0000000 """
This module is for building coordinate systems to be used when
building a CRS.
"""
from typing import Union
from pyproj._crs import CoordinateSystem
from pyproj.crs.enums import (
Cartesian2DCSAxis,
Ellipsoidal2DCSAxis,
Ellipsoidal3DCSAxis,
VerticalCSAxis,
)
# useful constants to use when setting PROJ JSON units
UNIT_METRE = "metre"
UNIT_DEGREE = "degree"
UNIT_FT = {"type": "LinearUnit", "name": "foot", "conversion_factor": 0.3048}
UNIT_US_FT = {
"type": "LinearUnit",
"name": "US survey foot",
"conversion_factor": 0.304800609601219,
}
_ELLIPSOIDAL_2D_AXIS_MAP = {
Ellipsoidal2DCSAxis.LONGITUDE_LATITUDE: [
{
"name": "Longitude",
"abbreviation": "lon",
"direction": "east",
"unit": UNIT_DEGREE,
},
{
"name": "Latitude",
"abbreviation": "lat",
"direction": "north",
"unit": UNIT_DEGREE,
},
],
Ellipsoidal2DCSAxis.LATITUDE_LONGITUDE: [
{
"name": "Latitude",
"abbreviation": "lat",
"direction": "north",
"unit": UNIT_DEGREE,
},
{
"name": "Longitude",
"abbreviation": "lon",
"direction": "east",
"unit": UNIT_DEGREE,
},
],
}
class Ellipsoidal2DCS(CoordinateSystem):
"""
.. versionadded:: 2.5.0
This generates an Ellipsoidal 2D Coordinate System
"""
def __new__(
cls,
axis: Union[Ellipsoidal2DCSAxis, str] = Ellipsoidal2DCSAxis.LONGITUDE_LATITUDE,
):
"""
Parameters
----------
axis: :class:`pyproj.crs.enums.Ellipsoidal2DCSAxis` or str, optional
This is the axis order of the coordinate system. Default is
:attr:`pyproj.crs.enums.Ellipsoidal2DCSAxis.LONGITUDE_LATITUDE`.
"""
return cls.from_json_dict(
{
"type": "CoordinateSystem",
"subtype": "ellipsoidal",
"axis": _ELLIPSOIDAL_2D_AXIS_MAP[Ellipsoidal2DCSAxis.create(axis)],
}
)
_ELLIPSOIDAL_3D_AXIS_MAP = {
Ellipsoidal3DCSAxis.LONGITUDE_LATITUDE_HEIGHT: [
{
"name": "Longitude",
"abbreviation": "lon",
"direction": "east",
"unit": UNIT_DEGREE,
},
{
"name": "Latitude",
"abbreviation": "lat",
"direction": "north",
"unit": UNIT_DEGREE,
},
{
"name": "Ellipsoidal height",
"abbreviation": "h",
"direction": "up",
"unit": UNIT_METRE,
},
],
Ellipsoidal3DCSAxis.LATITUDE_LONGITUDE_HEIGHT: [
{
"name": "Latitude",
"abbreviation": "lat",
"direction": "north",
"unit": UNIT_DEGREE,
},
{
"name": "Longitude",
"abbreviation": "lon",
"direction": "east",
"unit": UNIT_DEGREE,
},
{
"name": "Ellipsoidal height",
"abbreviation": "h",
"direction": "up",
"unit": UNIT_METRE,
},
],
}
class Ellipsoidal3DCS(CoordinateSystem):
"""
.. versionadded:: 2.5.0
This generates an Ellipsoidal 3D Coordinate System
"""
def __new__(
cls,
axis: Union[
Ellipsoidal3DCSAxis, str
] = Ellipsoidal3DCSAxis.LONGITUDE_LATITUDE_HEIGHT,
):
"""
Parameters
----------
axis: :class:`pyproj.crs.enums.Ellipsoidal3DCSAxis` or str, optional
This is the axis order of the coordinate system. Default is
:attr:`pyproj.crs.enums.Ellipsoidal3DCSAxis.LONGITUDE_LATITUDE_HEIGHT`.
"""
return cls.from_json_dict(
{
"type": "CoordinateSystem",
"subtype": "ellipsoidal",
"axis": _ELLIPSOIDAL_3D_AXIS_MAP[Ellipsoidal3DCSAxis.create(axis)],
}
)
_CARTESIAN_2D_AXIS_MAP = {
Cartesian2DCSAxis.EASTING_NORTHING: [
{
"name": "Easting",
"abbreviation": "E",
"direction": "east",
"unit": UNIT_METRE,
},
{
"name": "Northing",
"abbreviation": "N",
"direction": "north",
"unit": UNIT_METRE,
},
],
Cartesian2DCSAxis.NORTHING_EASTING: [
{
"name": "Northing",
"abbreviation": "N",
"direction": "north",
"unit": UNIT_METRE,
},
{
"name": "Easting",
"abbreviation": "E",
"direction": "east",
"unit": UNIT_METRE,
},
],
Cartesian2DCSAxis.EASTING_NORTHING_FT: [
{"name": "Easting", "abbreviation": "X", "direction": "east", "unit": UNIT_FT},
{
"name": "Northing",
"abbreviation": "Y",
"direction": "north",
"unit": UNIT_FT,
},
],
Cartesian2DCSAxis.NORTHING_EASTING_FT: [
{
"name": "Northing",
"abbreviation": "Y",
"direction": "north",
"unit": UNIT_FT,
},
{"name": "Easting", "abbreviation": "X", "direction": "east", "unit": UNIT_FT},
],
Cartesian2DCSAxis.EASTING_NORTHING_US_FT: [
{
"name": "Easting",
"abbreviation": "X",
"direction": "east",
"unit": UNIT_US_FT,
},
{
"name": "Northing",
"abbreviation": "Y",
"direction": "north",
"unit": UNIT_US_FT,
},
],
Cartesian2DCSAxis.NORTHING_EASTING_US_FT: [
{
"name": "Northing",
"abbreviation": "Y",
"direction": "north",
"unit": UNIT_US_FT,
},
{
"name": "Easting",
"abbreviation": "X",
"direction": "east",
"unit": UNIT_US_FT,
},
],
Cartesian2DCSAxis.NORTH_POLE_EASTING_SOUTH_NORTHING_SOUTH: [
{
"name": "Easting",
"abbreviation": "E",
"direction": "south",
"unit": UNIT_METRE,
},
{
"name": "Northing",
"abbreviation": "N",
"direction": "south",
"unit": UNIT_METRE,
},
],
Cartesian2DCSAxis.SOUTH_POLE_EASTING_NORTH_NORTHING_NORTH: [
{
"name": "Easting",
"abbreviation": "E",
"direction": "north",
"unit": UNIT_METRE,
},
{
"name": "Northing",
"abbreviation": "N",
"direction": "north",
"unit": UNIT_METRE,
},
],
Cartesian2DCSAxis.WESTING_SOUTHING: [
{
"name": "Easting",
"abbreviation": "Y",
"direction": "west",
"unit": UNIT_METRE,
},
{
"name": "Northing",
"abbreviation": "X",
"direction": "south",
"unit": UNIT_METRE,
},
],
}
class Cartesian2DCS(CoordinateSystem):
"""
.. versionadded:: 2.5.0
This generates an Cartesian 2D Coordinate System
"""
def __new__(
cls, axis: Union[Cartesian2DCSAxis, str] = Cartesian2DCSAxis.EASTING_NORTHING
):
"""
Parameters
----------
axis: :class:`pyproj.crs.enums.Cartesian2DCSAxis` or str, optional
This is the axis order of the coordinate system.
Default is :attr:`pyproj.crs.enums.Cartesian2DCSAxis.EASTING_NORTHING`.
"""
return cls.from_json_dict(
{
"type": "CoordinateSystem",
"subtype": "Cartesian",
"axis": _CARTESIAN_2D_AXIS_MAP[Cartesian2DCSAxis.create(axis)],
}
)
_VERTICAL_AXIS_MAP = {
VerticalCSAxis.GRAVITY_HEIGHT: {
"name": "Gravity-related height",
"abbreviation": "H",
"direction": "up",
"unit": UNIT_METRE,
},
VerticalCSAxis.GRAVITY_HEIGHT_US_FT: {
"name": "Gravity-related height",
"abbreviation": "H",
"direction": "up",
"unit": UNIT_US_FT,
},
VerticalCSAxis.GRAVITY_HEIGHT_FT: {
"name": "Gravity-related height",
"abbreviation": "H",
"direction": "up",
"unit": UNIT_FT,
},
VerticalCSAxis.DEPTH: {
"name": "Depth",
"abbreviation": "D",
"direction": "down",
"unit": UNIT_METRE,
},
VerticalCSAxis.DEPTH_US_FT: {
"name": "Depth",
"abbreviation": "D",
"direction": "down",
"unit": UNIT_US_FT,
},
VerticalCSAxis.DEPTH_FT: {
"name": "Depth",
"abbreviation": "D",
"direction": "down",
"unit": UNIT_FT,
},
VerticalCSAxis.UP: {
"name": "up",
"abbreviation": "H",
"direction": "up",
"unit": UNIT_METRE,
},
VerticalCSAxis.UP_FT: {
"name": "up",
"abbreviation": "H",
"direction": "up",
"unit": UNIT_FT,
},
VerticalCSAxis.UP_US_FT: {
"name": "up",
"abbreviation": "H",
"direction": "up",
"unit": UNIT_US_FT,
},
}
class VerticalCS(CoordinateSystem):
"""
.. versionadded:: 2.5.0
This generates an Vertical Coordinate System
"""
def __new__(cls, axis: Union[VerticalCSAxis, str] = VerticalCSAxis.GRAVITY_HEIGHT):
"""
Parameters
----------
axis: :class:`pyproj.crs.enums.VerticalCSAxis` or str, optional
This is the axis direction of the coordinate system.
Default is :attr:`pyproj.crs.enums.VerticalCSAxis.GRAVITY_HEIGHT`.
"""
return cls.from_json_dict(
{
"type": "CoordinateSystem",
"subtype": "vertical",
"axis": [_VERTICAL_AXIS_MAP[VerticalCSAxis.create(axis)]],
}
)
pyproj-3.6.1/pyproj/crs/crs.py 0000664 0000000 0000000 00000175143 14502715416 0016337 0 ustar 00root root 0000000 0000000 """
This module interfaces with PROJ to produce a pythonic interface
to the coordinate reference system (CRS) information.
"""
# pylint: disable=too-many-lines
import json
import re
import threading
import warnings
from typing import Any, Callable, Optional, Union
from pyproj._crs import (
_CRS,
AreaOfUse,
AuthorityMatchInfo,
Axis,
CoordinateOperation,
CoordinateSystem,
Datum,
Ellipsoid,
PrimeMeridian,
_load_proj_json,
is_proj,
is_wkt,
)
from pyproj.crs._cf1x8 import (
_GEOGRAPHIC_GRID_MAPPING_NAME_MAP,
_GRID_MAPPING_NAME_MAP,
_INVERSE_GEOGRAPHIC_GRID_MAPPING_NAME_MAP,
_INVERSE_GRID_MAPPING_NAME_MAP,
_horizontal_datum_from_params,
_try_list_if_string,
)
from pyproj.crs.coordinate_operation import ToWGS84Transformation
from pyproj.crs.coordinate_system import Cartesian2DCS, Ellipsoidal2DCS, VerticalCS
from pyproj.enums import ProjVersion, WktVersion
from pyproj.exceptions import CRSError
from pyproj.geod import Geod
_RE_PROJ_PARAM = re.compile(
r"""
\+ # parameter starts with '+' character
(?P\w+) # capture parameter name
\=? # match both key only and key-value parameters
(?P\S+)? # capture all characters up to next space (None if no value)
\s*? # consume remaining whitespace, if any
""",
re.X,
)
class CRSLocal(threading.local):
"""
Threading local instance for cython CRS class.
For more details, see:
https://github.com/pyproj4/pyproj/issues/782
"""
def __init__(self):
self.crs = None # Initialises in each thread
super().__init__()
def _prepare_from_dict(projparams: dict, allow_json: bool = True) -> str:
if not isinstance(projparams, dict):
raise CRSError("CRS input is not a dict")
# check if it is a PROJ JSON dict
if "proj" not in projparams and "init" not in projparams and allow_json:
return json.dumps(projparams)
# convert a dict to a proj string.
pjargs = []
for key, value in projparams.items():
# the towgs84 as list
if isinstance(value, (list, tuple)):
value = ",".join([str(val) for val in value])
# issue 183 (+ no_rot)
if value is None or str(value) == "True":
pjargs.append(f"+{key}")
elif str(value) == "False":
pass
else:
pjargs.append(f"+{key}={value}")
return _prepare_from_string(" ".join(pjargs))
def _prepare_from_proj_string(in_crs_string: str) -> str:
in_crs_string = re.sub(r"[\s+]?=[\s+]?", "=", in_crs_string.lstrip())
# make sure the projection starts with +proj or +init
starting_params = ("+init", "+proj", "init", "proj")
if not in_crs_string.startswith(starting_params):
kvpairs: list[str] = []
first_item_inserted = False
for kvpair in in_crs_string.split():
if not first_item_inserted and (kvpair.startswith(starting_params)):
kvpairs.insert(0, kvpair)
first_item_inserted = True
else:
kvpairs.append(kvpair)
in_crs_string = " ".join(kvpairs)
# make sure it is the CRS type
if "type=crs" not in in_crs_string:
if "+" in in_crs_string:
in_crs_string += " +type=crs"
else:
in_crs_string += " type=crs"
# look for EPSG, replace with epsg (EPSG only works
# on case-insensitive filesystems).
in_crs_string = in_crs_string.replace("+init=EPSG", "+init=epsg").strip()
if in_crs_string.startswith(("+init", "init")):
warnings.warn(
"'+init=:' syntax is deprecated. "
"':' is the preferred initialization method. "
"When making the change, be mindful of axis order changes: "
"https://pyproj4.github.io/pyproj/stable/gotchas.html"
"#axis-order-changes-in-proj-6",
FutureWarning,
stacklevel=2,
)
return in_crs_string
def _prepare_from_string(in_crs_string: str) -> str:
if not isinstance(in_crs_string, str):
raise CRSError("CRS input is not a string")
if not in_crs_string:
raise CRSError(f"CRS string is empty or invalid: {in_crs_string!r}")
if "{" in in_crs_string:
# may be json, try to decode it
try:
crs_dict = json.loads(in_crs_string, strict=False)
except ValueError as err:
raise CRSError("CRS appears to be JSON but is not valid") from err
if not crs_dict:
raise CRSError("CRS is empty JSON")
in_crs_string = _prepare_from_dict(crs_dict)
elif is_proj(in_crs_string):
in_crs_string = _prepare_from_proj_string(in_crs_string)
return in_crs_string
def _prepare_from_authority(auth_name: str, auth_code: Union[str, int]):
return f"{auth_name}:{auth_code}"
def _prepare_from_epsg(auth_code: Union[str, int]):
return _prepare_from_authority("EPSG", auth_code)
def _is_epsg_code(auth_code: Any) -> bool:
if isinstance(auth_code, int):
return True
if isinstance(auth_code, str) and auth_code.isnumeric():
return True
if hasattr(auth_code, "shape") and auth_code.shape == ():
return True
return False
class CRS:
"""
A pythonic Coordinate Reference System manager.
.. versionadded:: 2.0.0
See: :c:func:`proj_create`
The functionality is based on other fantastic projects:
* `rasterio `_ # noqa: E501
* `opendatacube `_ # noqa: E501
Attributes
----------
srs: str
The string form of the user input used to create the CRS.
"""
def __init__(self, projparams: Optional[Any] = None, **kwargs) -> None:
"""
Initialize a CRS class instance with:
- PROJ string
- Dictionary of PROJ parameters
- PROJ keyword arguments for parameters
- JSON string with PROJ parameters
- CRS WKT string
- An authority string [i.e. 'epsg:4326']
- An EPSG integer code [i.e. 4326]
- A tuple of ("auth_name": "auth_code") [i.e ('epsg', '4326')]
- An object with a `to_wkt` method.
- A :class:`pyproj.crs.CRS` class
Example usage:
>>> from pyproj import CRS
>>> crs_utm = CRS.from_user_input(26915)
>>> crs_utm
Name: NAD83 / UTM zone 15N
Axis Info [cartesian]:
- E[east]: Easting (metre)
- N[north]: Northing (metre)
Area of Use:
- name: North America - 96°W to 90°W and NAD83 by country
- bounds: (-96.0, 25.61, -90.0, 84.0)
Coordinate Operation:
- name: UTM zone 15N
- method: Transverse Mercator
Datum: North American Datum 1983
- Ellipsoid: GRS 1980
- Prime Meridian: Greenwich
>>> crs_utm.area_of_use.bounds
(-96.0, 25.61, -90.0, 84.0)
>>> crs_utm.ellipsoid
ELLIPSOID["GRS 1980",6378137,298.257222101,
LENGTHUNIT["metre",1],
ID["EPSG",7019]]
>>> crs_utm.ellipsoid.inverse_flattening
298.257222101
>>> crs_utm.ellipsoid.semi_major_metre
6378137.0
>>> crs_utm.ellipsoid.semi_minor_metre
6356752.314140356
>>> crs_utm.prime_meridian
PRIMEM["Greenwich",0,
ANGLEUNIT["degree",0.0174532925199433],
ID["EPSG",8901]]
>>> crs_utm.prime_meridian.unit_name
'degree'
>>> crs_utm.prime_meridian.unit_conversion_factor
0.017453292519943295
>>> crs_utm.prime_meridian.longitude
0.0
>>> crs_utm.datum
DATUM["North American Datum 1983",
ELLIPSOID["GRS 1980",6378137,298.257222101,
LENGTHUNIT["metre",1]],
ID["EPSG",6269]]
>>> crs_utm.coordinate_system
CS[Cartesian,2],
AXIS["(E)",east,
ORDER[1],
LENGTHUNIT["metre",1,
ID["EPSG",9001]]],
AXIS["(N)",north,
ORDER[2],
LENGTHUNIT["metre",1,
ID["EPSG",9001]]]
>>> print(crs_utm.coordinate_operation.to_wkt(pretty=True))
CONVERSION["UTM zone 15N",
METHOD["Transverse Mercator",
ID["EPSG",9807]],
PARAMETER["Latitude of natural origin",0,
ANGLEUNIT["degree",0.0174532925199433],
ID["EPSG",8801]],
PARAMETER["Longitude of natural origin",-93,
ANGLEUNIT["degree",0.0174532925199433],
ID["EPSG",8802]],
PARAMETER["Scale factor at natural origin",0.9996,
SCALEUNIT["unity",1],
ID["EPSG",8805]],
PARAMETER["False easting",500000,
LENGTHUNIT["metre",1],
ID["EPSG",8806]],
PARAMETER["False northing",0,
LENGTHUNIT["metre",1],
ID["EPSG",8807]],
ID["EPSG",16015]]
>>> crs = CRS(proj='utm', zone=10, ellps='WGS84')
>>> print(crs.to_wkt(pretty=True))
PROJCRS["unknown",
BASEGEOGCRS["unknown",
DATUM["Unknown based on WGS84 ellipsoid",
ELLIPSOID["WGS 84",6378137,298.257223563,
LENGTHUNIT["metre",1],
ID["EPSG",7030]]],
PRIMEM["Greenwich",0,
ANGLEUNIT["degree",0.0174532925199433],
ID["EPSG",8901]]],
CONVERSION["UTM zone 10N",
METHOD["Transverse Mercator",
ID["EPSG",9807]],
PARAMETER["Latitude of natural origin",0,
ANGLEUNIT["degree",0.0174532925199433],
ID["EPSG",8801]],
PARAMETER["Longitude of natural origin",-123,
ANGLEUNIT["degree",0.0174532925199433],
ID["EPSG",8802]],
PARAMETER["Scale factor at natural origin",0.9996,
SCALEUNIT["unity",1],
ID["EPSG",8805]],
PARAMETER["False easting",500000,
LENGTHUNIT["metre",1],
ID["EPSG",8806]],
PARAMETER["False northing",0,
LENGTHUNIT["metre",1],
ID["EPSG",8807]],
ID["EPSG",16010]],
CS[Cartesian,2],
AXIS["(E)",east,
ORDER[1],
LENGTHUNIT["metre",1,
ID["EPSG",9001]]],
AXIS["(N)",north,
ORDER[2],
LENGTHUNIT["metre",1,
ID["EPSG",9001]]]]
>>> geod = crs.get_geod()
>>> f"+a={geod.a:.0f} +f={geod.f:.8f}"
'+a=6378137 +f=0.00335281'
>>> crs.is_projected
True
>>> crs.is_geographic
False
"""
projstring = ""
if projparams:
if isinstance(projparams, _CRS):
projstring = projparams.srs
elif _is_epsg_code(projparams):
projstring = _prepare_from_epsg(projparams)
elif isinstance(projparams, str):
projstring = _prepare_from_string(projparams)
elif isinstance(projparams, dict):
projstring = _prepare_from_dict(projparams)
elif isinstance(projparams, (list, tuple)) and len(projparams) == 2:
projstring = _prepare_from_authority(*projparams)
elif hasattr(projparams, "to_wkt"):
projstring = projparams.to_wkt() # type: ignore
else:
raise CRSError(f"Invalid CRS input: {projparams!r}")
if kwargs:
projkwargs = _prepare_from_dict(kwargs, allow_json=False)
projstring = _prepare_from_string(" ".join((projstring, projkwargs)))
self.srs = projstring
self._local = CRSLocal()
if isinstance(projparams, _CRS):
self._local.crs = projparams
else:
self._local.crs = _CRS(self.srs)
@property
def _crs(self):
"""
Retrieve the Cython based _CRS object for this thread.
"""
if self._local.crs is None:
self._local.crs = _CRS(self.srs)
return self._local.crs
@classmethod
def from_authority(cls, auth_name: str, code: Union[str, int]) -> "CRS":
"""
.. versionadded:: 2.2.0
Make a CRS from an authority name and authority code
Parameters
----------
auth_name: str
The name of the authority.
code : int or str
The code used by the authority.
Returns
-------
CRS
"""
return cls.from_user_input(_prepare_from_authority(auth_name, code))
@classmethod
def from_epsg(cls, code: Union[str, int]) -> "CRS":
"""Make a CRS from an EPSG code
Parameters
----------
code : int or str
An EPSG code.
Returns
-------
CRS
"""
return cls.from_user_input(_prepare_from_epsg(code))
@classmethod
def from_proj4(cls, in_proj_string: str) -> "CRS":
"""
.. versionadded:: 2.2.0
Make a CRS from a PROJ string
Parameters
----------
in_proj_string : str
A PROJ string.
Returns
-------
CRS
"""
if not is_proj(in_proj_string):
raise CRSError(f"Invalid PROJ string: {in_proj_string}")
return cls.from_user_input(_prepare_from_proj_string(in_proj_string))
@classmethod
def from_wkt(cls, in_wkt_string: str) -> "CRS":
"""
.. versionadded:: 2.2.0
Make a CRS from a WKT string
Parameters
----------
in_wkt_string : str
A WKT string.
Returns
-------
CRS
"""
if not is_wkt(in_wkt_string):
raise CRSError(f"Invalid WKT string: {in_wkt_string}")
return cls.from_user_input(_prepare_from_string(in_wkt_string))
@classmethod
def from_string(cls, in_crs_string: str) -> "CRS":
"""
Make a CRS from:
Initialize a CRS class instance with:
- PROJ string
- JSON string with PROJ parameters
- CRS WKT string
- An authority string [i.e. 'epsg:4326']
Parameters
----------
in_crs_string : str
An EPSG, PROJ, or WKT string.
Returns
-------
CRS
"""
return cls.from_user_input(_prepare_from_string(in_crs_string))
def to_string(self) -> str:
"""
.. versionadded:: 2.2.0
Convert the CRS to a string.
It attempts to convert it to the authority string.
Otherwise, it uses the string format of the user
input to create the CRS.
Returns
-------
str
"""
auth_info = self.to_authority(min_confidence=100)
if auth_info:
return ":".join(auth_info)
return self.srs
@classmethod
def from_user_input(cls, value: Any, **kwargs) -> "CRS":
"""
Initialize a CRS class instance with:
- PROJ string
- Dictionary of PROJ parameters
- PROJ keyword arguments for parameters
- JSON string with PROJ parameters
- CRS WKT string
- An authority string [i.e. 'epsg:4326']
- An EPSG integer code [i.e. 4326]
- A tuple of ("auth_name": "auth_code") [i.e ('epsg', '4326')]
- An object with a `to_wkt` method.
- A :class:`pyproj.crs.CRS` class
Parameters
----------
value : obj
A Python int, dict, or str.
Returns
-------
CRS
"""
if isinstance(value, cls):
return value
return cls(value, **kwargs)
def get_geod(self) -> Optional[Geod]:
"""
Returns
-------
pyproj.geod.Geod:
Geod object based on the ellipsoid.
"""
if self.ellipsoid is None:
return None
return Geod(
a=self.ellipsoid.semi_major_metre,
rf=self.ellipsoid.inverse_flattening,
b=self.ellipsoid.semi_minor_metre,
)
@classmethod
def from_dict(cls, proj_dict: dict) -> "CRS":
"""
.. versionadded:: 2.2.0
Make a CRS from a dictionary of PROJ parameters.
Parameters
----------
proj_dict : str
PROJ params in dict format.
Returns
-------
CRS
"""
return cls.from_user_input(_prepare_from_dict(proj_dict))
@classmethod
def from_json(cls, crs_json: str) -> "CRS":
"""
.. versionadded:: 2.4.0
Create CRS from a CRS JSON string.
Parameters
----------
crs_json: str
CRS JSON string.
Returns
-------
CRS
"""
return cls.from_user_input(_load_proj_json(crs_json))
@classmethod
def from_json_dict(cls, crs_dict: dict) -> "CRS":
"""
.. versionadded:: 2.4.0
Create CRS from a JSON dictionary.
Parameters
----------
crs_dict: dict
CRS dictionary.
Returns
-------
CRS
"""
return cls.from_user_input(json.dumps(crs_dict))
def to_dict(self) -> dict:
"""
.. versionadded:: 2.2.0
Converts the CRS to dictionary of PROJ parameters.
.. warning:: You will likely lose important projection
information when converting to a PROJ string from
another format. See: https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems # noqa: E501
Returns
-------
dict:
PROJ params in dict format.
"""
proj_string = self.to_proj4()
if proj_string is None:
return {}
def _parse(val):
if val.lower() == "true":
return True
if val.lower() == "false":
return False
try:
return int(val)
except ValueError:
pass
try:
return float(val)
except ValueError:
pass
return _try_list_if_string(val)
proj_dict = {}
for param in _RE_PROJ_PARAM.finditer(proj_string):
key, value = param.groups()
if value is not None:
value = _parse(value)
if value is not False:
proj_dict[key] = value
return proj_dict
def to_cf(
self,
wkt_version: Union[WktVersion, str] = WktVersion.WKT2_2019,
errcheck: bool = False,
) -> dict:
"""
.. versionadded:: 2.2.0
This converts a :obj:`pyproj.crs.CRS` object
to a Climate and Forecast (CF) Grid Mapping Version 1.8 dict.
:ref:`build_crs_cf`
Parameters
----------
wkt_version: str or pyproj.enums.WktVersion
Version of WKT supported by CRS.to_wkt.
Default is :attr:`pyproj.enums.WktVersion.WKT2_2019`.
errcheck: bool, default=False
If True, will warn when parameters are ignored.
Returns
-------
dict:
CF-1.8 version of the projection.
"""
# pylint: disable=too-many-branches,too-many-return-statements
cf_dict: dict[str, Any] = {"crs_wkt": self.to_wkt(wkt_version)}
# handle bound CRS
if (
self.is_bound
and self.coordinate_operation
and self.coordinate_operation.towgs84
and self.source_crs
):
sub_cf: dict[str, Any] = self.source_crs.to_cf(
wkt_version=wkt_version,
errcheck=errcheck,
)
sub_cf.pop("crs_wkt")
cf_dict.update(sub_cf)
cf_dict["towgs84"] = self.coordinate_operation.towgs84
return cf_dict
# handle compound CRS
if self.is_compound:
for sub_crs in self.sub_crs_list:
sub_cf = sub_crs.to_cf(wkt_version=wkt_version, errcheck=errcheck)
sub_cf.pop("crs_wkt")
cf_dict.update(sub_cf)
return cf_dict
# handle vertical CRS
if self.is_vertical:
vert_json = self.to_json_dict()
if "geoid_model" in vert_json:
cf_dict["geoid_name"] = vert_json["geoid_model"]["name"]
if self.datum:
cf_dict["geopotential_datum_name"] = self.datum.name
return cf_dict
# write out datum parameters
if self.ellipsoid:
cf_dict.update(
semi_major_axis=self.ellipsoid.semi_major_metre,
semi_minor_axis=self.ellipsoid.semi_minor_metre,
inverse_flattening=self.ellipsoid.inverse_flattening,
)
cf_dict["reference_ellipsoid_name"] = self.ellipsoid.name
if self.prime_meridian:
cf_dict["longitude_of_prime_meridian"] = self.prime_meridian.longitude
cf_dict["prime_meridian_name"] = self.prime_meridian.name
# handle geographic CRS
if self.geodetic_crs:
cf_dict["geographic_crs_name"] = self.geodetic_crs.name
if self.geodetic_crs.datum:
cf_dict["horizontal_datum_name"] = self.geodetic_crs.datum.name
if self.is_geographic:
if self.coordinate_operation:
if (
self.coordinate_operation.method_name.lower()
not in _INVERSE_GEOGRAPHIC_GRID_MAPPING_NAME_MAP
):
if errcheck:
warnings.warn(
"Unsupported coordinate operation: "
f"{self.coordinate_operation.method_name}"
)
return {"crs_wkt": cf_dict["crs_wkt"]}
cf_dict.update(
_INVERSE_GEOGRAPHIC_GRID_MAPPING_NAME_MAP[
self.coordinate_operation.method_name.lower()
](self.coordinate_operation)
)
else:
cf_dict["grid_mapping_name"] = "latitude_longitude"
return cf_dict
# handle projected CRS
coordinate_operation = None
if not self.is_bound and self.is_projected:
coordinate_operation = self.coordinate_operation
cf_dict["projected_crs_name"] = self.name
coordinate_operation_name = (
None
if not coordinate_operation
else coordinate_operation.method_name.lower().replace(" ", "_")
)
if coordinate_operation_name not in _INVERSE_GRID_MAPPING_NAME_MAP:
if errcheck:
if coordinate_operation:
warnings.warn(
"Unsupported coordinate operation: "
f"{coordinate_operation.method_name}"
)
else:
warnings.warn("Coordinate operation not found.")
return {"crs_wkt": cf_dict["crs_wkt"]}
cf_dict.update(
_INVERSE_GRID_MAPPING_NAME_MAP[coordinate_operation_name](
coordinate_operation
)
)
return cf_dict
@staticmethod
def from_cf(
in_cf: dict,
ellipsoidal_cs: Optional[Any] = None,
cartesian_cs: Optional[Any] = None,
vertical_cs: Optional[Any] = None,
) -> "CRS":
"""
.. versionadded:: 2.2.0
.. versionadded:: 3.0.0 ellipsoidal_cs, cartesian_cs, vertical_cs
This converts a Climate and Forecast (CF) Grid Mapping Version 1.8
dict to a :obj:`pyproj.crs.CRS` object.
:ref:`build_crs_cf`
Parameters
----------
in_cf: dict
CF version of the projection.
ellipsoidal_cs: Any, optional
Input to create an Ellipsoidal Coordinate System.
Anything accepted by :meth:`pyproj.crs.CoordinateSystem.from_user_input`
or an Ellipsoidal Coordinate System created from :ref:`coordinate_system`.
cartesian_cs: Any, optional
Input to create a Cartesian Coordinate System.
Anything accepted by :meth:`pyproj.crs.CoordinateSystem.from_user_input`
or :class:`pyproj.crs.coordinate_system.Cartesian2DCS`.
vertical_cs: Any, optional
Input to create a Vertical Coordinate System accepted by
:meth:`pyproj.crs.CoordinateSystem.from_user_input`
or :class:`pyproj.crs.coordinate_system.VerticalCS`
Returns
-------
CRS
"""
# pylint: disable=too-many-branches
unknown_names = ("unknown", "undefined")
if "crs_wkt" in in_cf:
return CRS(in_cf["crs_wkt"])
if "spatial_ref" in in_cf: # for previous supported WKT key
return CRS(in_cf["spatial_ref"])
grid_mapping_name = in_cf.get("grid_mapping_name")
if grid_mapping_name is None:
raise CRSError("CF projection parameters missing 'grid_mapping_name'")
# build datum if possible
datum = _horizontal_datum_from_params(in_cf)
# build geographic CRS
try:
geographic_conversion_method: Optional[
Callable
] = _GEOGRAPHIC_GRID_MAPPING_NAME_MAP[grid_mapping_name]
except KeyError:
geographic_conversion_method = None
geographic_crs_name = in_cf.get("geographic_crs_name")
if datum:
geographic_crs: CRS = GeographicCRS(
name=geographic_crs_name or "undefined",
datum=datum,
ellipsoidal_cs=ellipsoidal_cs,
)
elif geographic_crs_name and geographic_crs_name not in unknown_names:
geographic_crs = CRS(geographic_crs_name)
if ellipsoidal_cs is not None:
geographic_crs_json = geographic_crs.to_json_dict()
geographic_crs_json[
"coordinate_system"
] = CoordinateSystem.from_user_input(ellipsoidal_cs).to_json_dict()
geographic_crs = CRS(geographic_crs_json)
else:
geographic_crs = GeographicCRS(ellipsoidal_cs=ellipsoidal_cs)
if grid_mapping_name == "latitude_longitude":
return geographic_crs
if geographic_conversion_method is not None:
return DerivedGeographicCRS(
base_crs=geographic_crs,
conversion=geographic_conversion_method(in_cf),
ellipsoidal_cs=ellipsoidal_cs,
)
# build projected CRS
try:
conversion_method = _GRID_MAPPING_NAME_MAP[grid_mapping_name]
except KeyError:
raise CRSError(
f"Unsupported grid mapping name: {grid_mapping_name}"
) from None
projected_crs = ProjectedCRS(
name=in_cf.get("projected_crs_name", "undefined"),
conversion=conversion_method(in_cf),
geodetic_crs=geographic_crs,
cartesian_cs=cartesian_cs,
)
# build bound CRS if exists
bound_crs = None
if "towgs84" in in_cf:
bound_crs = BoundCRS(
source_crs=projected_crs,
target_crs="WGS 84",
transformation=ToWGS84Transformation(
projected_crs.geodetic_crs, *_try_list_if_string(in_cf["towgs84"])
),
)
if "geopotential_datum_name" not in in_cf:
return bound_crs or projected_crs
# build Vertical CRS
vertical_crs = VerticalCRS(
name="undefined",
datum=in_cf["geopotential_datum_name"],
geoid_model=in_cf.get("geoid_name"),
vertical_cs=vertical_cs,
)
# build compound CRS
return CompoundCRS(
name="undefined", components=[bound_crs or projected_crs, vertical_crs]
)
def cs_to_cf(self) -> list[dict]:
"""
.. versionadded:: 3.0.0
This converts all coordinate systems (cs) in the CRS
to a list of Climate and Forecast (CF) Version 1.8 dicts.
:ref:`build_crs_cf`
Returns
-------
list[dict]:
CF-1.8 version of the coordinate systems.
"""
cf_axis_list = []
def rotated_pole(crs):
try:
return (
crs.coordinate_operation
and crs.coordinate_operation.method_name.lower()
in _INVERSE_GEOGRAPHIC_GRID_MAPPING_NAME_MAP
)
except KeyError:
return False
if self.type_name == "Temporal CRS" and self.datum:
datum_json = self.datum.to_json_dict()
origin = datum_json.get("time_origin", "1875-05-20").strip().rstrip("zZ")
if len(origin) == 4:
origin = f"{origin}-01-01"
axis = self.axis_info[0]
cf_temporal_axis = {
"standard_name": "time",
"long_name": "time",
"calendar": (
datum_json.get("calendar", "proleptic_gregorian")
.lower()
.replace(" ", "_")
),
"axis": "T",
}
unit_name = axis.unit_name.lower().replace("calendar", "").strip()
# no units for TemporalDateTime
if unit_name:
cf_temporal_axis["units"] = f"{unit_name} since {origin}"
cf_axis_list.append(cf_temporal_axis)
if self.coordinate_system:
cf_axis_list.extend(
self.coordinate_system.to_cf(rotated_pole=rotated_pole(self))
)
elif self.is_bound and self.source_crs and self.source_crs.coordinate_system:
cf_axis_list.extend(
self.source_crs.coordinate_system.to_cf(
rotated_pole=rotated_pole(self.source_crs)
)
)
else:
for sub_crs in self.sub_crs_list:
cf_axis_list.extend(sub_crs.cs_to_cf())
return cf_axis_list
def is_exact_same(self, other: Any) -> bool:
"""
Check if the CRS objects are the exact same.
Parameters
----------
other: Any
Check if the other CRS is the exact same to this object.
If the other object is not a CRS, it will try to create one.
On Failure, it will return False.
Returns
-------
bool
"""
try:
other = CRS.from_user_input(other)
except CRSError:
return False
return self._crs.is_exact_same(other._crs)
def equals(self, other: Any, ignore_axis_order: bool = False) -> bool:
"""
.. versionadded:: 2.5.0
Check if the CRS objects are equivalent.
Parameters
----------
other: Any
Check if the other object is equivalent to this object.
If the other object is not a CRS, it will try to create one.
On Failure, it will return False.
ignore_axis_order: bool, default=False
If True, it will compare the CRS class and ignore the axis order.
Returns
-------
bool
"""
try:
other = CRS.from_user_input(other)
except CRSError:
return False
return self._crs.equals(other._crs, ignore_axis_order=ignore_axis_order)
@property
def geodetic_crs(self) -> Optional["CRS"]:
"""
.. versionadded:: 2.2.0
Returns
-------
CRS:
The geodeticCRS / geographicCRS from the CRS.
"""
return (
None
if self._crs.geodetic_crs is None
else self.__class__(self._crs.geodetic_crs)
)
@property
def source_crs(self) -> Optional["CRS"]:
"""
The base CRS of a BoundCRS or a DerivedCRS/ProjectedCRS,
or the source CRS of a CoordinateOperation.
Returns
-------
CRS
"""
return (
None
if self._crs.source_crs is None
else self.__class__(self._crs.source_crs)
)
@property
def target_crs(self) -> Optional["CRS"]:
"""
.. versionadded:: 2.2.0
Returns
-------
CRS:
The hub CRS of a BoundCRS or the target CRS of a CoordinateOperation.
"""
return (
None
if self._crs.target_crs is None
else self.__class__(self._crs.target_crs)
)
@property
def sub_crs_list(self) -> list["CRS"]:
"""
If the CRS is a compound CRS, it will return a list of sub CRS objects.
Returns
-------
list[CRS]
"""
return [self.__class__(sub_crs) for sub_crs in self._crs.sub_crs_list]
@property
def utm_zone(self) -> Optional[str]:
"""
.. versionadded:: 2.6.0
Finds the UTM zone in a Projected CRS, Bound CRS, or Compound CRS
Returns
-------
Optional[str]:
The UTM zone number and letter if applicable.
"""
if self.is_bound and self.source_crs:
return self.source_crs.utm_zone
if self.sub_crs_list:
for sub_crs in self.sub_crs_list:
if sub_crs.utm_zone:
return sub_crs.utm_zone
elif (
self.coordinate_operation
and "UTM ZONE" in self.coordinate_operation.name.upper()
):
return self.coordinate_operation.name.upper().split("UTM ZONE ")[-1]
return None
@property
def name(self) -> str:
"""
Returns
-------
str:
The name of the CRS (from :cpp:func:`proj_get_name`).
"""
return self._crs.name
@property
def type_name(self) -> str:
"""
Returns
-------
str:
The name of the type of the CRS object.
"""
return self._crs.type_name
@property
def axis_info(self) -> list[Axis]:
"""
Retrieves all relevant axis information in the CRS.
If it is a Bound CRS, it gets the axis list from the Source CRS.
If it is a Compound CRS, it gets the axis list from the Sub CRS list.
Returns
-------
list[Axis]:
The list of axis information.
"""
return self._crs.axis_info
@property
def area_of_use(self) -> Optional[AreaOfUse]:
"""
Returns
-------
AreaOfUse:
The area of use object with associated attributes.
"""
return self._crs.area_of_use
@property
def ellipsoid(self) -> Optional[Ellipsoid]:
"""
.. versionadded:: 2.2.0
Returns
-------
Ellipsoid:
The ellipsoid object with associated attributes.
"""
return self._crs.ellipsoid
@property
def prime_meridian(self) -> Optional[PrimeMeridian]:
"""
.. versionadded:: 2.2.0
Returns
-------
PrimeMeridian:
The prime meridian object with associated attributes.
"""
return self._crs.prime_meridian
@property
def datum(self) -> Optional[Datum]:
"""
.. versionadded:: 2.2.0
Returns
-------
Datum
"""
return self._crs.datum
@property
def coordinate_system(self) -> Optional[CoordinateSystem]:
"""
.. versionadded:: 2.2.0
Returns
-------
CoordinateSystem
"""
return self._crs.coordinate_system
@property
def coordinate_operation(self) -> Optional[CoordinateOperation]:
"""
.. versionadded:: 2.2.0
Returns
-------
CoordinateOperation
"""
return self._crs.coordinate_operation
@property
def remarks(self) -> str:
"""
.. versionadded:: 2.4.0
Returns
-------
str:
Remarks about object.
"""
return self._crs.remarks
@property
def scope(self) -> str:
"""
.. versionadded:: 2.4.0
Returns
-------
str:
Scope of object.
"""
return self._crs.scope
def to_wkt(
self,
version: Union[WktVersion, str] = WktVersion.WKT2_2019,
pretty: bool = False,
output_axis_rule: Optional[bool] = None,
) -> str:
"""
Convert the projection to a WKT string.
Version options:
- WKT2_2015
- WKT2_2015_SIMPLIFIED
- WKT2_2019
- WKT2_2019_SIMPLIFIED
- WKT1_GDAL
- WKT1_ESRI
.. versionadded:: 3.6.0 output_axis_rule
Parameters
----------
version: pyproj.enums.WktVersion, optional
The version of the WKT output.
Default is :attr:`pyproj.enums.WktVersion.WKT2_2019`.
pretty: bool, default=False
If True, it will set the output to be a multiline string.
output_axis_rule: bool, optional, default=None
If True, it will set the axis rule on any case. If false, never.
None for AUTO, that depends on the CRS and version.
Returns
-------
str
"""
wkt = self._crs.to_wkt(
version=version, pretty=pretty, output_axis_rule=output_axis_rule
)
if wkt is None:
raise CRSError(
f"CRS cannot be converted to a WKT string of a '{version}' version. "
"Select a different version of a WKT string or edit your CRS."
)
return wkt
def to_json(self, pretty: bool = False, indentation: int = 2) -> str:
"""
.. versionadded:: 2.4.0
Convert the object to a JSON string.
Parameters
----------
pretty: bool, default=False
If True, it will set the output to be a multiline string.
indentation: int, default=2
If pretty is True, it will set the width of the indentation.
Returns
-------
str
"""
proj_json = self._crs.to_json(pretty=pretty, indentation=indentation)
if proj_json is None:
raise CRSError("CRS cannot be converted to a PROJ JSON string.")
return proj_json
def to_json_dict(self) -> dict:
"""
.. versionadded:: 2.4.0
Convert the object to a JSON dictionary.
Returns
-------
dict
"""
return self._crs.to_json_dict()
def to_proj4(self, version: Union[ProjVersion, int] = ProjVersion.PROJ_5) -> str:
"""
Convert the projection to a PROJ string.
.. warning:: You will likely lose important projection
information when converting to a PROJ string from
another format. See:
https://proj.org/faq.html#what-is-the-best-format-for-describing-coordinate-reference-systems # noqa: E501
Parameters
----------
version: pyproj.enums.ProjVersion
The version of the PROJ string output.
Default is :attr:`pyproj.enums.ProjVersion.PROJ_4`.
Returns
-------
str
"""
proj = self._crs.to_proj4(version=version)
if proj is None:
raise CRSError("CRS cannot be converted to a PROJ string.")
return proj
def to_epsg(self, min_confidence: int = 70) -> Optional[int]:
"""
Return the EPSG code best matching the CRS
or None if it a match is not found.
Example:
>>> from pyproj import CRS
>>> ccs = CRS("EPSG:4328")
>>> ccs.to_epsg()
4328
If the CRS is bound, you can attempt to get an epsg code from
the source CRS:
>>> from pyproj import CRS
>>> ccs = CRS("+proj=geocent +datum=WGS84 +towgs84=0,0,0")
>>> ccs.to_epsg()
>>> ccs.source_crs.to_epsg()
4978
>>> ccs == CRS.from_epsg(4978)
False
Parameters
----------
min_confidence: int, default=70
A value between 0-100 where 100 is the most confident.
:ref:`min_confidence`
Returns
-------
Optional[int]:
The best matching EPSG code matching the confidence level.
"""
return self._crs.to_epsg(min_confidence=min_confidence)
def to_authority(self, auth_name: Optional[str] = None, min_confidence: int = 70):
"""
.. versionadded:: 2.2.0
Return the authority name and code best matching the CRS
or None if it a match is not found.
Example:
>>> from pyproj import CRS
>>> ccs = CRS("EPSG:4328")
>>> ccs.to_authority()
('EPSG', '4328')
If the CRS is bound, you can get an authority from
the source CRS:
>>> from pyproj import CRS
>>> ccs = CRS("+proj=geocent +datum=WGS84 +towgs84=0,0,0")
>>> ccs.to_authority()
>>> ccs.source_crs.to_authority()
('EPSG', '4978')
>>> ccs == CRS.from_authorty('EPSG', '4978')
False
Parameters
----------
auth_name: str, optional
The name of the authority to filter by.
min_confidence: int, default=70
A value between 0-100 where 100 is the most confident.
:ref:`min_confidence`
Returns
-------
tuple(str, str) or None:
The best matching (, ) for the confidence level.
"""
return self._crs.to_authority(
auth_name=auth_name, min_confidence=min_confidence
)
def list_authority(
self, auth_name: Optional[str] = None, min_confidence: int = 70
) -> list[AuthorityMatchInfo]:
"""
.. versionadded:: 3.2.0
Return the authority names and codes best matching the CRS.
Example:
>>> from pyproj import CRS
>>> ccs = CRS("EPSG:4328")
>>> ccs.list_authority()
[AuthorityMatchInfo(auth_name='EPSG', code='4326', confidence=100)]
If the CRS is bound, you can get an authority from
the source CRS:
>>> from pyproj import CRS
>>> ccs = CRS("+proj=geocent +datum=WGS84 +towgs84=0,0,0")
>>> ccs.list_authority()
[]
>>> ccs.source_crs.list_authority()
[AuthorityMatchInfo(auth_name='EPSG', code='4978', confidence=70)]
>>> ccs == CRS.from_authorty('EPSG', '4978')
False
Parameters
----------
auth_name: str, optional
The name of the authority to filter by.
min_confidence: int, default=70
A value between 0-100 where 100 is the most confident.
:ref:`min_confidence`
Returns
-------
list[AuthorityMatchInfo]:
List of authority matches for the CRS.
"""
return self._crs.list_authority(
auth_name=auth_name, min_confidence=min_confidence
)
def to_3d(self, name: Optional[str] = None) -> "CRS":
"""
.. versionadded:: 3.1.0
Convert the current CRS to the 3D version if it makes sense.
New vertical axis attributes:
- ellipsoidal height
- oriented upwards
- metre units
Parameters
----------
name: str, optional
CRS name. Defaults to use the name of the original CRS.
Returns
-------
CRS
"""
return self.__class__(self._crs.to_3d(name=name))
def to_2d(self, name: Optional[str] = None) -> "CRS":
"""
.. versionadded:: 3.6.0
Convert the current CRS to the 2D version if it makes sense.
Parameters
----------
name: str, optional
CRS name. Defaults to use the name of the original CRS.
Returns
-------
CRS
"""
return self.__class__(self._crs.to_2d(name=name))
@property
def is_geographic(self) -> bool:
"""
This checks if the CRS is geographic.
It will check if it has a geographic CRS
in the sub CRS if it is a compound CRS and will check if
the source CRS is geographic if it is a bound CRS.
Returns
-------
bool:
True if the CRS is in geographic (lon/lat) coordinates.
"""
return self._crs.is_geographic
@property
def is_projected(self) -> bool:
"""
This checks if the CRS is projected.
It will check if it has a projected CRS
in the sub CRS if it is a compound CRS and will check if
the source CRS is projected if it is a bound CRS.
Returns
-------
bool:
True if CRS is projected.
"""
return self._crs.is_projected
@property
def is_vertical(self) -> bool:
"""
.. versionadded:: 2.2.0
This checks if the CRS is vertical.
It will check if it has a vertical CRS
in the sub CRS if it is a compound CRS and will check if
the source CRS is vertical if it is a bound CRS.
Returns
-------
bool:
True if CRS is vertical.
"""
return self._crs.is_vertical
@property
def is_bound(self) -> bool:
"""
Returns
-------
bool:
True if CRS is bound.
"""
return self._crs.is_bound
@property
def is_compound(self) -> bool:
"""
.. versionadded:: 3.1.0
Returns
-------
bool:
True if CRS is compound.
"""
return self._crs.is_compound
@property
def is_engineering(self) -> bool:
"""
.. versionadded:: 2.2.0
Returns
-------
bool:
True if CRS is local/engineering.
"""
return self._crs.is_engineering
@property
def is_geocentric(self) -> bool:
"""
This checks if the CRS is geocentric and
takes into account if the CRS is bound.
Returns
-------
bool:
True if CRS is in geocentric (x/y) coordinates.
"""
return self._crs.is_geocentric
@property
def is_derived(self):
"""
.. versionadded:: 3.2.0
Returns
-------
bool:
True if CRS is a Derived CRS.
"""
return self._crs.is_derived
def __eq__(self, other: Any) -> bool:
return self.equals(other)
def __getstate__(self) -> dict[str, str]:
return {"srs": self.srs}
def __setstate__(self, state: dict[str, Any]):
self.__dict__.update(state)
self._local = CRSLocal()
def __hash__(self) -> int:
return hash(self.to_wkt())
def __str__(self) -> str:
return self.srs
def __repr__(self) -> str:
# get axis information
axis_info_list: list[str] = []
for axis in self.axis_info:
axis_info_list.extend(["- ", str(axis), "\n"])
axis_info_str = "".join(axis_info_list)
# get coordinate system & sub CRS info
source_crs_repr = ""
sub_crs_repr = ""
if self.coordinate_system and self.coordinate_system.axis_list:
coordinate_system_name = str(self.coordinate_system)
elif self.is_bound and self.source_crs:
coordinate_system_name = str(self.source_crs.coordinate_system)
source_crs_repr = f"Source CRS: {self.source_crs.name}\n"
else:
coordinate_system_names = []
sub_crs_repr_list = ["Sub CRS:\n"]
for sub_crs in self.sub_crs_list:
coordinate_system_names.append(str(sub_crs.coordinate_system))
sub_crs_repr_list.extend(["- ", sub_crs.name, "\n"])
coordinate_system_name = "|".join(coordinate_system_names)
sub_crs_repr = "".join(sub_crs_repr_list)
# get coordinate operation repr
coordinate_operation = ""
if self.coordinate_operation:
coordinate_operation = "".join(
[
"Coordinate Operation:\n",
"- name: ",
str(self.coordinate_operation),
"\n- method: ",
self.coordinate_operation.method_name,
"\n",
]
)
# get SRS representation
srs_repr = self.to_string()
srs_repr = srs_repr if len(srs_repr) <= 50 else " ".join([srs_repr[:50], "..."])
axis_info_str = axis_info_str or "- undefined\n"
return (
f"<{self.type_name}: {srs_repr}>\n"
f"Name: {self.name}\n"
f"Axis Info [{coordinate_system_name or 'undefined'}]:\n"
f"{axis_info_str}"
"Area of Use:\n"
f"{self.area_of_use or '- undefined'}\n"
f"{coordinate_operation}"
f"Datum: {self.datum}\n"
f"- Ellipsoid: {self.ellipsoid or 'undefined'}\n"
f"- Prime Meridian: {self.prime_meridian or 'undefined'}\n"
f"{source_crs_repr}"
f"{sub_crs_repr}"
)
class CustomConstructorCRS(CRS):
"""
This class is a base class for CRS classes
that use a different constructor than the main CRS class.
.. versionadded:: 3.2.0
See: https://github.com/pyproj4/pyproj/issues/847
"""
@property
def _expected_types(self) -> tuple[str, ...]:
"""
These are the type names of the CRS class
that are expected when using the from_* methods.
"""
raise NotImplementedError
def _check_type(self):
"""
This validates that the type of the CRS is expected
when using the from_* methods.
"""
if self.type_name not in self._expected_types:
raise CRSError(
f"Invalid type {self.type_name}. Expected {self._expected_types}."
)
@classmethod
def from_user_input(cls, value: Any, **kwargs) -> "CRS":
"""
Initialize a CRS class instance with:
- PROJ string
- Dictionary of PROJ parameters
- PROJ keyword arguments for parameters
- JSON string with PROJ parameters
- CRS WKT string
- An authority string [i.e. 'epsg:4326']
- An EPSG integer code [i.e. 4326]
- A tuple of ("auth_name": "auth_code") [i.e ('epsg', '4326')]
- An object with a `to_wkt` method.
- A :class:`pyproj.crs.CRS` class
Parameters
----------
value : obj
A Python int, dict, or str.
Returns
-------
CRS
"""
if isinstance(value, cls):
return value
crs = cls.__new__(cls)
super(CustomConstructorCRS, crs).__init__(value, **kwargs)
crs._check_type()
return crs
@property
def geodetic_crs(self) -> Optional["CRS"]:
"""
.. versionadded:: 2.2.0
Returns
-------
CRS:
The geodeticCRS / geographicCRS from the CRS.
"""
return None if self._crs.geodetic_crs is None else CRS(self._crs.geodetic_crs)
@property
def source_crs(self) -> Optional["CRS"]:
"""
The base CRS of a BoundCRS or a DerivedCRS/ProjectedCRS,
or the source CRS of a CoordinateOperation.
Returns
-------
CRS
"""
return None if self._crs.source_crs is None else CRS(self._crs.source_crs)
@property
def target_crs(self) -> Optional["CRS"]:
"""
.. versionadded:: 2.2.0
Returns
-------
CRS:
The hub CRS of a BoundCRS or the target CRS of a CoordinateOperation.
"""
return None if self._crs.target_crs is None else CRS(self._crs.target_crs)
@property
def sub_crs_list(self) -> list["CRS"]:
"""
If the CRS is a compound CRS, it will return a list of sub CRS objects.
Returns
-------
list[CRS]
"""
return [CRS(sub_crs) for sub_crs in self._crs.sub_crs_list]
def to_3d(self, name: Optional[str] = None) -> "CRS":
"""
.. versionadded:: 3.1.0
Convert the current CRS to the 3D version if it makes sense.
New vertical axis attributes:
- ellipsoidal height
- oriented upwards
- metre units
Parameters
----------
name: str, optional
CRS name. Defaults to use the name of the original CRS.
Returns
-------
CRS
"""
return CRS(self._crs.to_3d(name=name))
class GeographicCRS(CustomConstructorCRS):
"""
.. versionadded:: 2.5.0
This class is for building a Geographic CRS
"""
_expected_types = ("Geographic CRS", "Geographic 2D CRS", "Geographic 3D CRS")
def __init__(
self,
name: str = "undefined",
datum: Any = "urn:ogc:def:ensemble:EPSG::6326",
ellipsoidal_cs: Optional[Any] = None,
) -> None:
"""
Parameters
----------
name: str, default="undefined"
Name of the CRS.
datum: Any, default="urn:ogc:def:ensemble:EPSG::6326"
Anything accepted by :meth:`pyproj.crs.Datum.from_user_input` or
a :class:`pyproj.crs.datum.CustomDatum`.
ellipsoidal_cs: Any, optional
Input to create an Ellipsoidal Coordinate System.
Anything accepted by :meth:`pyproj.crs.CoordinateSystem.from_user_input`
or an Ellipsoidal Coordinate System created from :ref:`coordinate_system`.
"""
datum = Datum.from_user_input(datum).to_json_dict()
geographic_crs_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "GeographicCRS",
"name": name,
"coordinate_system": CoordinateSystem.from_user_input(
ellipsoidal_cs or Ellipsoidal2DCS()
).to_json_dict(),
}
if datum["type"] == "DatumEnsemble":
geographic_crs_json["datum_ensemble"] = datum
else:
geographic_crs_json["datum"] = datum
super().__init__(geographic_crs_json)
class DerivedGeographicCRS(CustomConstructorCRS):
"""
.. versionadded:: 2.5.0
This class is for building a Derived Geographic CRS
"""
_expected_types = (
"Derived Geographic CRS",
"Derived Geographic 2D CRS",
"Derived Geographic 3D CRS",
)
def __init__(
self,
base_crs: Any,
conversion: Any,
ellipsoidal_cs: Optional[Any] = None,
name: str = "undefined",
) -> None:
"""
Parameters
----------
base_crs: Any
Input to create the Geodetic CRS, a :class:`GeographicCRS` or
anything accepted by :meth:`pyproj.crs.CRS.from_user_input`.
conversion: Any
Anything accepted by :meth:`pyproj.crs.CoordinateSystem.from_user_input`
or a conversion from :ref:`coordinate_operation`.
ellipsoidal_cs: Any, optional
Input to create an Ellipsoidal Coordinate System.
Anything accepted by :meth:`pyproj.crs.CoordinateSystem.from_user_input`
or an Ellipsoidal Coordinate System created from :ref:`coordinate_system`.
name: str, default="undefined"
Name of the CRS.
"""
derived_geographic_crs_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "DerivedGeographicCRS",
"name": name,
"base_crs": CRS.from_user_input(base_crs).to_json_dict(),
"conversion": CoordinateOperation.from_user_input(
conversion
).to_json_dict(),
"coordinate_system": CoordinateSystem.from_user_input(
ellipsoidal_cs or Ellipsoidal2DCS()
).to_json_dict(),
}
super().__init__(derived_geographic_crs_json)
class GeocentricCRS(CustomConstructorCRS):
"""
.. versionadded:: 3.2.0
This class is for building a Geocentric CRS
"""
_expected_types = ("Geocentric CRS",)
def __init__(
self,
name: str = "undefined",
datum: Any = "urn:ogc:def:datum:EPSG::6326",
) -> None:
"""
Parameters
----------
name: str, default="undefined"
Name of the CRS.
datum: Any, default="urn:ogc:def:datum:EPSG::6326"
Anything accepted by :meth:`pyproj.crs.Datum.from_user_input` or
a :class:`pyproj.crs.datum.CustomDatum`.
"""
geocentric_crs_json = {
"$schema": ("https://proj.org/schemas/v0.2/projjson.schema.json"),
"type": "GeodeticCRS",
"name": name,
"datum": Datum.from_user_input(datum).to_json_dict(),
"coordinate_system": {
"subtype": "Cartesian",
"axis": [
{
"name": "Geocentric X",
"abbreviation": "X",
"direction": "geocentricX",
"unit": "metre",
},
{
"name": "Geocentric Y",
"abbreviation": "Y",
"direction": "geocentricY",
"unit": "metre",
},
{
"name": "Geocentric Z",
"abbreviation": "Z",
"direction": "geocentricZ",
"unit": "metre",
},
],
},
}
super().__init__(geocentric_crs_json)
class ProjectedCRS(CustomConstructorCRS):
"""
.. versionadded:: 2.5.0
This class is for building a Projected CRS.
"""
_expected_types = ("Projected CRS", "Derived Projected CRS")
def __init__(
self,
conversion: Any,
name: str = "undefined",
cartesian_cs: Optional[Any] = None,
geodetic_crs: Optional[Any] = None,
) -> None:
"""
Parameters
----------
conversion: Any
Anything accepted by :meth:`pyproj.crs.CoordinateSystem.from_user_input`
or a conversion from :ref:`coordinate_operation`.
name: str, optional
The name of the Projected CRS. Default is undefined.
cartesian_cs: Any, optional
Input to create a Cartesian Coordinate System.
Anything accepted by :meth:`pyproj.crs.CoordinateSystem.from_user_input`
or :class:`pyproj.crs.coordinate_system.Cartesian2DCS`.
geodetic_crs: Any, optional
Input to create the Geodetic CRS, a :class:`GeographicCRS` or
anything accepted by :meth:`pyproj.crs.CRS.from_user_input`.
"""
proj_crs_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "ProjectedCRS",
"name": name,
"base_crs": CRS.from_user_input(
geodetic_crs or GeographicCRS()
).to_json_dict(),
"conversion": CoordinateOperation.from_user_input(
conversion
).to_json_dict(),
"coordinate_system": CoordinateSystem.from_user_input(
cartesian_cs or Cartesian2DCS()
).to_json_dict(),
}
super().__init__(proj_crs_json)
class VerticalCRS(CustomConstructorCRS):
"""
.. versionadded:: 2.5.0
This class is for building a Vetical CRS.
.. warning:: geoid_model support only exists in PROJ >= 6.3.0
"""
_expected_types = ("Vertical CRS",)
def __init__(
self,
name: str,
datum: Any,
vertical_cs: Optional[Any] = None,
geoid_model: Optional[str] = None,
) -> None:
"""
Parameters
----------
name: str
The name of the Vertical CRS (e.g. NAVD88 height).
datum: Any
Anything accepted by :meth:`pyproj.crs.Datum.from_user_input`
vertical_cs: Any, optional
Input to create a Vertical Coordinate System accepted by
:meth:`pyproj.crs.CoordinateSystem.from_user_input`
or :class:`pyproj.crs.coordinate_system.VerticalCS`
geoid_model: str, optional
The name of the GEOID Model (e.g. GEOID12B).
"""
vert_crs_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "VerticalCRS",
"name": name,
"datum": Datum.from_user_input(datum).to_json_dict(),
"coordinate_system": CoordinateSystem.from_user_input(
vertical_cs or VerticalCS()
).to_json_dict(),
}
if geoid_model is not None:
vert_crs_json["geoid_model"] = {"name": geoid_model}
super().__init__(vert_crs_json)
class CompoundCRS(CustomConstructorCRS):
"""
.. versionadded:: 2.5.0
This class is for building a Compound CRS.
"""
_expected_types = ("Compound CRS",)
def __init__(self, name: str, components: list[Any]) -> None:
"""
Parameters
----------
name: str
The name of the Compound CRS.
components: list[Any], optional
List of CRS to create a Compound Coordinate System.
List of anything accepted by :meth:`pyproj.crs.CRS.from_user_input`
"""
compound_crs_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "CompoundCRS",
"name": name,
"components": [
CRS.from_user_input(component).to_json_dict()
for component in components
],
}
super().__init__(compound_crs_json)
class BoundCRS(CustomConstructorCRS):
"""
.. versionadded:: 2.5.0
This class is for building a Bound CRS.
"""
_expected_types = ("Bound CRS",)
def __init__(self, source_crs: Any, target_crs: Any, transformation: Any) -> None:
"""
Parameters
----------
source_crs: Any
Input to create a source CRS.
target_crs: Any
Input to create the target CRS.
transformation: Any
Input to create the transformation.
"""
bound_crs_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "BoundCRS",
"source_crs": CRS.from_user_input(source_crs).to_json_dict(),
"target_crs": CRS.from_user_input(target_crs).to_json_dict(),
"transformation": CoordinateOperation.from_user_input(
transformation
).to_json_dict(),
}
super().__init__(bound_crs_json)
pyproj-3.6.1/pyproj/crs/datum.py 0000664 0000000 0000000 00000007204 14502715416 0016652 0 ustar 00root root 0000000 0000000 """
This module is for building datums to be used when
building a CRS.
"""
from typing import Any, Optional, Union
from pyproj._crs import Datum, Ellipsoid, PrimeMeridian
class CustomDatum(Datum):
"""
.. versionadded:: 2.5.0
Class to build a datum based on an ellipsoid and prime meridian.
"""
def __new__(
cls,
name: str = "undefined",
ellipsoid: Any = "WGS 84",
prime_meridian: Any = "Greenwich",
):
"""
Parameters
----------
name: str, default="undefined"
Name of the datum.
ellipsoid: Any, default="WGS 84"
Anything accepted by :meth:`pyproj.crs.Ellipsoid.from_user_input`
or a :class:`pyproj.crs.datum.CustomEllipsoid`.
prime_meridian: Any, default="Greenwich"
Anything accepted by :meth:`pyproj.crs.PrimeMeridian.from_user_input`.
"""
datum_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "GeodeticReferenceFrame",
"name": name,
"ellipsoid": Ellipsoid.from_user_input(ellipsoid).to_json_dict(),
"prime_meridian": PrimeMeridian.from_user_input(
prime_meridian
).to_json_dict(),
}
return cls.from_json_dict(datum_json)
class CustomEllipsoid(Ellipsoid):
"""
.. versionadded:: 2.5.0
Class to build a custom ellipsoid.
"""
def __new__(
cls,
name: str = "undefined",
semi_major_axis: Optional[float] = None,
inverse_flattening: Optional[float] = None,
semi_minor_axis: Optional[float] = None,
radius: Optional[float] = None,
):
"""
Parameters
----------
name: str, default="undefined"
Name of the ellipsoid.
semi_major_axis: float, optional
The semi major axis in meters. Required if missing radius.
inverse_flattening: float, optional
The inverse flattening in meters.
Required if missing semi_minor_axis and radius.
semi_minor_axis: float, optional
The semi minor axis in meters.
Required if missing inverse_flattening and radius.
radius: float, optional
The radius in meters. Can only be used alone.
Cannot be mixed with other parameters.
"""
ellipsoid_json: dict[str, Union[float, str]] = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "Ellipsoid",
"name": name,
}
if semi_major_axis is not None:
ellipsoid_json["semi_major_axis"] = semi_major_axis
if inverse_flattening is not None:
ellipsoid_json["inverse_flattening"] = inverse_flattening
if semi_minor_axis is not None:
ellipsoid_json["semi_minor_axis"] = semi_minor_axis
if radius is not None:
ellipsoid_json["radius"] = radius
return cls.from_json_dict(ellipsoid_json)
class CustomPrimeMeridian(PrimeMeridian):
"""
.. versionadded:: 2.5.0
Class to build a prime meridian based on a longitude.
"""
def __new__(cls, longitude: float, name: str = "undefined"):
"""
Parameters
----------
longitude: float
Longitude of prime meridian.
name: str, optional
Name of the prime meridian.
"""
datum_json = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "PrimeMeridian",
"name": name,
"longitude": longitude,
}
return cls.from_json_dict(datum_json)
pyproj-3.6.1/pyproj/crs/enums.py 0000664 0000000 0000000 00000007132 14502715416 0016667 0 ustar 00root root 0000000 0000000 """
This module contains enumerations used in pyproj.crs.
"""
from pyproj.enums import BaseEnum
class DatumType(BaseEnum):
"""
.. versionadded:: 2.5.0
Datum Types for creating datum with :meth:`pyproj.crs.Datum.from_name`
Attributes
----------
GEODETIC_REFERENCE_FRAME
DYNAMIC_GEODETIC_REFERENCE_FRAME
VERTICAL_REFERENCE_FRAME
DYNAMIC_VERTICAL_REFERENCE_FRAME
DATUM_ENSEMBLE
"""
GEODETIC_REFERENCE_FRAME = "GEODETIC_REFERENCE_FRAME"
DYNAMIC_GEODETIC_REFERENCE_FRAME = "DYNAMIC_GEODETIC_REFERENCE_FRAME"
VERTICAL_REFERENCE_FRAME = "VERTICAL_REFERENCE_FRAME"
DYNAMIC_VERTICAL_REFERENCE_FRAME = "DYNAMIC_VERTICAL_REFERENCE_FRAME"
DATUM_ENSEMBLE = "DATUM_ENSEMBLE"
class CoordinateOperationType(BaseEnum):
"""
.. versionadded:: 2.5.0
Coordinate Operation Types for creating operation
with :meth:`pyproj.crs.CoordinateOperation.from_name`
Attributes
----------
CONVERSION
TRANSFORMATION
CONCATENATED_OPERATION
OTHER_COORDINATE_OPERATION
"""
CONVERSION = "CONVERSION"
TRANSFORMATION = "TRANSFORMATION"
CONCATENATED_OPERATION = "CONCATENATED_OPERATION"
OTHER_COORDINATE_OPERATION = "OTHER_COORDINATE_OPERATION"
class Cartesian2DCSAxis(BaseEnum):
"""
.. versionadded:: 2.5.0
Cartesian 2D Coordinate System Axis for creating axis with
with :class:`pyproj.crs.coordinate_system.Cartesian2DCS`
Attributes
----------
EASTING_NORTHING
NORTHING_EASTING
EASTING_NORTHING_FT
NORTHING_EASTING_FT
EASTING_NORTHING_US_FT
NORTHING_EASTING_US_FT
NORTH_POLE_EASTING_SOUTH_NORTHING_SOUTH
SOUTH_POLE_EASTING_NORTH_NORTHING_NORTH
WESTING_SOUTHING
"""
EASTING_NORTHING = "EASTING_NORTHING"
NORTHING_EASTING = "NORTHING_EASTING"
EASTING_NORTHING_FT = "EASTING_NORTHING_FT"
NORTHING_EASTING_FT = "NORTHING_EASTING_FT"
EASTING_NORTHING_US_FT = "EASTING_NORTHING_US_FT"
NORTHING_EASTING_US_FT = "NORTHING_EASTING_US_FT"
NORTH_POLE_EASTING_SOUTH_NORTHING_SOUTH = "NORTH_POLE_EASTING_SOUTH_NORTHING_SOUTH"
SOUTH_POLE_EASTING_NORTH_NORTHING_NORTH = "SOUTH_POLE_EASTING_NORTH_NORTHING_NORTH"
WESTING_SOUTHING = "WESTING_SOUTHING"
class Ellipsoidal2DCSAxis(BaseEnum):
"""
.. versionadded:: 2.5.0
Ellipsoidal 2D Coordinate System Axis for creating axis with
with :class:`pyproj.crs.coordinate_system.Ellipsoidal2DCS`
Attributes
----------
LONGITUDE_LATITUDE
LATITUDE_LONGITUDE
"""
LONGITUDE_LATITUDE = "LONGITUDE_LATITUDE"
LATITUDE_LONGITUDE = "LATITUDE_LONGITUDE"
class Ellipsoidal3DCSAxis(BaseEnum):
"""
.. versionadded:: 2.5.0
Ellipsoidal 3D Coordinate System Axis for creating axis with
with :class:`pyproj.crs.coordinate_system.Ellipsoidal3DCS`
Attributes
----------
LONGITUDE_LATITUDE_HEIGHT
LATITUDE_LONGITUDE_HEIGHT
"""
LONGITUDE_LATITUDE_HEIGHT = "LONGITUDE_LATITUDE_HEIGHT"
LATITUDE_LONGITUDE_HEIGHT = "LATITUDE_LONGITUDE_HEIGHT"
class VerticalCSAxis(BaseEnum):
"""
.. versionadded:: 2.5.0
Vertical Coordinate System Axis for creating axis with
with :class:`pyproj.crs.coordinate_system.VerticalCS`
Attributes
----------
UP
UP_FT
UP_US_FT
DEPTH
DEPTH_FT
DEPTH_US_FT
GRAVITY_HEIGHT
GRAVITY_HEIGHT_FT
GRAVITY_HEIGHT_US_FT
"""
GRAVITY_HEIGHT = "GRAVITY_HEIGHT"
GRAVITY_HEIGHT_FT = "GRAVITY_HEIGHT_FT"
GRAVITY_HEIGHT_US_FT = "GRAVITY_HEIGHT_US_FT"
DEPTH = "DEPTH"
DEPTH_FT = "DEPTH_FT"
DEPTH_US_FT = "DEPTH_US_FT"
UP = "UP"
UP_FT = "UP_FT"
UP_US_FT = "UP_US_FT"
pyproj-3.6.1/pyproj/database.pyi 0000664 0000000 0000000 00000002404 14502715416 0016663 0 ustar 00root root 0000000 0000000 from typing import NamedTuple, Optional, Union
from pyproj.aoi import AreaOfInterest, AreaOfUse
from pyproj.enums import PJType
class Unit(NamedTuple):
auth_name: str
code: str
name: str
category: str
conv_factor: float
proj_short_name: Optional[str]
deprecated: bool
def get_units_map(
auth_name: Optional[str] = None,
category: Optional[str] = None,
allow_deprecated: bool = False,
) -> dict[str, Unit]: ...
def get_authorities() -> list[str]: ...
def get_codes(
auth_name: str, pj_type: Union[PJType, str], allow_deprecated: bool = False
) -> list[str]: ...
class CRSInfo(NamedTuple):
auth_name: str
code: str
name: str
type: PJType
deprecated: bool
area_of_use: Optional[AreaOfUse]
projection_method_name: Optional[str]
def query_crs_info(
auth_name: Optional[str] = None,
pj_types: Union[PJType, list[PJType], None] = None,
area_of_interest: Optional[AreaOfInterest] = None,
contains: bool = False,
allow_deprecated: bool = False,
) -> list[CRSInfo]: ...
def query_utm_crs_info(
datum_name: Optional[str] = None,
area_of_interest: Optional[AreaOfInterest] = None,
contains: bool = False,
) -> list[CRSInfo]: ...
def get_database_metadata(key: str) -> Optional[str]: ...
pyproj-3.6.1/pyproj/database.pyx 0000664 0000000 0000000 00000035123 14502715416 0016706 0 ustar 00root root 0000000 0000000 include "proj.pxi"
import warnings
from collections import namedtuple
from typing import Optional
from libc.stdlib cimport free, malloc
from pyproj._compat cimport cstrdecode, cstrencode
from pyproj._datadir cimport pyproj_context_create, pyproj_context_destroy
from pyproj.aoi import AreaOfUse
from pyproj.enums import PJType
cdef dict _PJ_TYPE_MAP = {
PJType.UNKNOWN: PJ_TYPE_UNKNOWN,
PJType.ELLIPSOID: PJ_TYPE_ELLIPSOID,
PJType.PRIME_MERIDIAN: PJ_TYPE_PRIME_MERIDIAN,
PJType.GEODETIC_REFERENCE_FRAME: PJ_TYPE_GEODETIC_REFERENCE_FRAME,
PJType.DYNAMIC_GEODETIC_REFERENCE_FRAME: PJ_TYPE_DYNAMIC_GEODETIC_REFERENCE_FRAME,
PJType.VERTICAL_REFERENCE_FRAME: PJ_TYPE_VERTICAL_REFERENCE_FRAME,
PJType.DYNAMIC_VERTICAL_REFERENCE_FRAME: PJ_TYPE_DYNAMIC_VERTICAL_REFERENCE_FRAME,
PJType.DATUM_ENSEMBLE: PJ_TYPE_DATUM_ENSEMBLE,
PJType.CRS: PJ_TYPE_CRS,
PJType.GEODETIC_CRS: PJ_TYPE_GEODETIC_CRS,
PJType.GEOCENTRIC_CRS: PJ_TYPE_GEOCENTRIC_CRS,
PJType.GEOGRAPHIC_CRS: PJ_TYPE_GEOGRAPHIC_CRS,
PJType.GEOGRAPHIC_2D_CRS: PJ_TYPE_GEOGRAPHIC_2D_CRS,
PJType.GEOGRAPHIC_3D_CRS: PJ_TYPE_GEOGRAPHIC_3D_CRS,
PJType.VERTICAL_CRS: PJ_TYPE_VERTICAL_CRS,
PJType.PROJECTED_CRS: PJ_TYPE_PROJECTED_CRS,
PJType.COMPOUND_CRS: PJ_TYPE_COMPOUND_CRS,
PJType.TEMPORAL_CRS: PJ_TYPE_TEMPORAL_CRS,
PJType.ENGINEERING_CRS: PJ_TYPE_ENGINEERING_CRS,
PJType.BOUND_CRS: PJ_TYPE_BOUND_CRS,
PJType.OTHER_CRS: PJ_TYPE_OTHER_CRS,
PJType.CONVERSION: PJ_TYPE_CONVERSION,
PJType.TRANSFORMATION: PJ_TYPE_TRANSFORMATION,
PJType.CONCATENATED_OPERATION: PJ_TYPE_CONCATENATED_OPERATION,
PJType.OTHER_COORDINATE_OPERATION: PJ_TYPE_OTHER_COORDINATE_OPERATION,
}
IF (CTE_PROJ_VERSION_MAJOR, CTE_PROJ_VERSION_MINOR) >= (9, 2):
_PJ_TYPE_MAP[PJType.DERIVED_PROJECTED_CRS] = PJ_TYPE_DERIVED_PROJECTED_CRS
cdef dict _INV_PJ_TYPE_MAP = {value: key for key, value in _PJ_TYPE_MAP.items()}
cdef PJ_TYPE get_pj_type(pj_type) except *:
if not isinstance(pj_type, PJType):
pj_type = PJType.create(pj_type)
IF (CTE_PROJ_VERSION_MAJOR, CTE_PROJ_VERSION_MINOR) < (9, 2):
if pj_type is PJType.DERIVED_PROJECTED_CRS:
raise NotImplementedError(
"DERIVED_PROJECTED_CRS requires PROJ 9.2+"
)
return _PJ_TYPE_MAP[pj_type]
def get_authorities():
"""
.. versionadded:: 2.4.0
See: :c:func:`proj_get_authorities_from_database`
Returns
-------
list[str]:
Authorities in PROJ database.
"""
cdef PJ_CONTEXT* context = pyproj_context_create()
cdef PROJ_STRING_LIST proj_auth_list = proj_get_authorities_from_database(context)
if proj_auth_list == NULL:
pyproj_context_destroy(context)
return []
cdef int iii = 0
try:
auth_list = []
while proj_auth_list[iii] != NULL:
auth_list.append(proj_auth_list[iii])
iii += 1
finally:
pyproj_context_destroy(context)
proj_string_list_destroy(proj_auth_list)
return auth_list
def get_codes(str auth_name not None, pj_type not None, bint allow_deprecated=False):
"""
.. versionadded:: 2.4.0
See: :c:func:`proj_get_codes_from_database`
Parameters
----------
auth_name: str
The name of the authority.
pj_type: pyproj.enums.PJType
The type of object to get the authorities.
allow_deprecated: bool, default=False
Allow a deprecated code in the return.
Returns
-------
list[str]:
Codes associated with authorities in PROJ database.
"""
cdef PJ_CONTEXT* context = NULL
cdef PJ_TYPE cpj_type = get_pj_type(pj_type)
cdef PROJ_STRING_LIST proj_code_list = NULL
try:
context = pyproj_context_create()
proj_code_list = proj_get_codes_from_database(
context,
cstrencode(auth_name),
cpj_type,
allow_deprecated,
)
finally:
pyproj_context_destroy(context)
if proj_code_list == NULL:
return []
cdef int iii = 0
try:
code_list = []
while proj_code_list[iii] != NULL:
code_list.append(proj_code_list[iii])
iii += 1
finally:
proj_string_list_destroy(proj_code_list)
return code_list
CRSInfo = namedtuple(
"CRSInfo",
[
"auth_name",
"code",
"name",
"type",
"deprecated",
"area_of_use",
"projection_method_name",
],
)
CRSInfo.__doc__ = """
.. versionadded:: 3.0.0
CRS Information
Parameters
----------
auth_name: str
Authority name.
code: str
Object code.
name: str
Object name.
type: PJType
The type of CRS
deprecated: bool
Whether the object is deprecated.
area_of_use: Optional[AreaOfUse]
The area of use for the CRS if valid.
projection_method_name: Optional[str]
Name of the projection method for a projected CRS.
"""
def query_crs_info(
str auth_name=None,
pj_types=None,
area_of_interest=None,
bint contains=False,
bint allow_deprecated=False,
):
"""
.. versionadded:: 3.0.0
Query for CRS information from the PROJ database.
See: :c:func:`proj_get_crs_info_list_from_database`
Parameters
----------
auth_name: Optional[str], optional
The name of the authority. Default is all authorities.
pj_types: Union[pyproj.enums.PJType, list[pyproj.enums.PJType], None], optional
The type(s) of CRS to get the information (i.e. the types with CRS in the name).
If None is provided, it will use all of types (i.e. PJType.CRS).
area_of_interest: Optional[AreaOfInterest], optional
Filter returned CRS by the area of interest. Default method is intersection.
contains: bool, default=False
Only works if the area of interest is passed in.
If True, then only CRS whose area of use entirely contains the specified
bounding box will be returned. If False, then only CRS whose area of use
intersects the specified bounding box will be returned.
allow_deprecated: bool, default=False
Allow a deprecated code in the return.
Returns
-------
list[CRSInfo]:
CRS information from the PROJ database.
"""
cdef PJ_CONTEXT* context = NULL
cdef PJ_TYPE *pj_type_list = NULL
cdef PROJ_CRS_LIST_PARAMETERS *query_params = NULL
cdef PROJ_CRS_INFO **crs_info_list = NULL
cdef const char* c_auth_name = NULL
cdef int result_count = 0
cdef int pj_type_count = 0
cdef int iii = 0
cdef bytes b_auth_name
if auth_name is not None:
b_auth_name = cstrencode(auth_name)
c_auth_name = b_auth_name
try:
if pj_types is not None:
if isinstance(pj_types, (PJType, str)):
pj_types = (pj_types,)
pj_type_count = len(pj_types)
pj_type_list = malloc(
pj_type_count * sizeof(PJ_TYPE)
)
for iii in range(pj_type_count):
pj_type_list[iii] = get_pj_type(pj_types[iii])
context = pyproj_context_create()
query_params = proj_get_crs_list_parameters_create()
query_params.types = pj_type_list
query_params.typesCount = pj_type_count
query_params.allow_deprecated = bool(allow_deprecated)
if area_of_interest:
query_params.crs_area_of_use_contains_bbox = bool(contains)
query_params.bbox_valid = True
query_params.west_lon_degree = area_of_interest.west_lon_degree
query_params.south_lat_degree = area_of_interest.south_lat_degree
query_params.east_lon_degree = area_of_interest.east_lon_degree
query_params.north_lat_degree = area_of_interest.north_lat_degree
crs_info_list = proj_get_crs_info_list_from_database(
context,
c_auth_name,
query_params,
&result_count)
finally:
if query_params != NULL:
proj_get_crs_list_parameters_destroy(query_params)
if pj_type_list != NULL:
free(pj_type_list)
pyproj_context_destroy(context)
if crs_info_list == NULL:
return []
try:
code_list = []
iii = 0
while crs_info_list[iii] != NULL:
area_of_use = None
if crs_info_list[iii].bbox_valid:
area_of_use = AreaOfUse(
west=crs_info_list[iii].west_lon_degree,
south=crs_info_list[iii].south_lat_degree,
east=crs_info_list[iii].east_lon_degree,
north=crs_info_list[iii].north_lat_degree,
name=cstrdecode(crs_info_list[iii].area_name),
)
code_list.append(CRSInfo(
auth_name=crs_info_list[iii].auth_name,
code=crs_info_list[iii].code,
name=crs_info_list[iii].name,
type=_INV_PJ_TYPE_MAP[crs_info_list[iii].type],
deprecated=bool(crs_info_list[iii].deprecated),
area_of_use=area_of_use,
projection_method_name=cstrdecode(
crs_info_list[iii].projection_method_name
)
))
iii += 1
finally:
proj_crs_info_list_destroy(crs_info_list)
return code_list
def query_utm_crs_info(
str datum_name=None,
area_of_interest=None,
bint contains=False,
):
"""
.. versionadded:: 3.0.0
Query for EPSG UTM CRS information from the PROJ database.
See: :c:func:`proj_get_crs_info_list_from_database`
Parameters
----------
datum_name: Optional[str], optional
The name of the datum in the CRS name ('NAD27', 'NAD83', 'WGS 84', ...).
area_of_interest: Optional[AreaOfInterest], optional
Filter returned CRS by the area of interest. Default method is intersection.
contains: bool, default=False
Only works if the area of interest is passed in.
If True, then only CRS whose area of use entirely contains the specified
bounding box will be returned. If False, then only CRS whose area of use
intersects the specified bounding box will be returned.
Returns
-------
list[CRSInfo]:
UTM CRS information from the PROJ database.
"""
projected_crs = query_crs_info(
auth_name="EPSG",
pj_types=PJType.PROJECTED_CRS,
area_of_interest=area_of_interest,
contains=contains,
)
utm_crs = [crs for crs in projected_crs if "UTM zone" in crs.name]
if datum_name is None:
return utm_crs
datum_name = datum_name.replace(" ", "")
return [
crs for crs in utm_crs
if datum_name == crs.name.split("/")[0].replace(" ", "")
]
Unit = namedtuple(
"Unit",
[
"auth_name",
"code",
"name",
"category",
"conv_factor",
"proj_short_name",
"deprecated",
],
)
Unit.__doc__ = """
.. versionadded:: 3.0.0
Parameters
----------
auth_name: str
Authority name.
code: str
Object code.
name: str
Object name. For example "metre", "US survey foot", etc.
category: str
Category of the unit: one of "linear", "linear_per_time", "angular",
"angular_per_time", "scale", "scale_per_time" or "time".
conv_factor: float
Conversion factor to apply to transform from that unit to the
corresponding SI unit (metre for "linear", radian for "angular", etc.).
It might be 0 in some cases to indicate no known conversion factor.
proj_short_name: Optional[str]
PROJ short name, like "m", "ft", "us-ft", etc... Might be None.
deprecated: bool
Whether the object is deprecated.
"""
def get_units_map(str auth_name=None, str category=None, bint allow_deprecated=False):
"""
.. versionadded:: 2.2.0
.. versionadded:: 3.0.0 query PROJ database.
Get the units available in the PROJ database.
See: :c:func:`proj_get_units_from_database`
Parameters
----------
auth_name: str, optional
The authority name to filter by (e.g. EPSG, PROJ). Default is all.
category: str, optional
Category of the unit: one of "linear", "linear_per_time", "angular",
"angular_per_time", "scale", "scale_per_time" or "time". Default is all.
allow_deprecated: bool, default=False
Whether or not to allow deprecated units.
Returns
-------
dict[str, Unit]
"""
cdef const char* c_auth_name = NULL
cdef const char* c_category = NULL
cdef bytes b_auth_name
cdef bytes b_category
if auth_name is not None:
b_auth_name = cstrencode(auth_name)
c_auth_name = b_auth_name
if category is not None:
b_category = cstrencode(category)
c_category = b_category
cdef int num_units = 0
cdef PJ_CONTEXT* context = pyproj_context_create()
cdef PROJ_UNIT_INFO** db_unit_list = proj_get_units_from_database(
context,
c_auth_name,
c_category,
bool(allow_deprecated),
&num_units,
)
units_map = {}
try:
for iii in range(num_units):
proj_short_name = None
if db_unit_list[iii].proj_short_name != NULL:
proj_short_name = db_unit_list[iii].proj_short_name
name = db_unit_list[iii].name
units_map[name] = Unit(
auth_name=db_unit_list[iii].auth_name,
code=db_unit_list[iii].code,
name=name,
category=db_unit_list[iii].category,
conv_factor=db_unit_list[iii].conv_factor,
proj_short_name=proj_short_name,
deprecated=bool(db_unit_list[iii].deprecated),
)
finally:
proj_unit_list_destroy(db_unit_list)
pyproj_context_destroy(context)
return units_map
def get_database_metadata(str key not None):
"""
Return metadata from the database.
See: :c:func:`proj_context_get_database_metadata`
Available keys:
- DATABASE.LAYOUT.VERSION.MAJOR
- DATABASE.LAYOUT.VERSION.MINOR
- EPSG.VERSION
- EPSG.DATE
- ESRI.VERSION
- ESRI.DATE
- IGNF.SOURCE
- IGNF.VERSION
- IGNF.DATE
- NKG.SOURCE
- NKG.VERSION
- NKG.DATE
- PROJ.VERSION
- PROJ_DATA.VERSION : PROJ-data version most compatible with this database.
Parameters
----------
key: str
The name of the metadata item to get data for.
Returns
-------
Optional[str]:
The metatada information if available.
"""
cdef PJ_CONTEXT* context = pyproj_context_create()
cdef const char* metadata = NULL
try:
metadata = proj_context_get_database_metadata(
context,
cstrdecode(key),
)
if metadata == NULL:
return None
return metadata
finally:
pyproj_context_destroy(context)
pyproj-3.6.1/pyproj/datadir.py 0000664 0000000 0000000 00000007444 14502715416 0016367 0 ustar 00root root 0000000 0000000 """
Module for managing the PROJ data directory.
"""
# pylint: disable=global-statement
import os
import shutil
import sys
from pathlib import Path
from typing import Union
from pyproj._datadir import ( # noqa: F401 pylint: disable=unused-import
_global_context_set_data_dir,
get_user_data_dir,
)
from pyproj.exceptions import DataDirError
_USER_PROJ_DATA = None
_VALIDATED_PROJ_DATA = None
def set_data_dir(proj_data_dir: Union[str, Path]) -> None:
"""
Set the data directory for PROJ to use.
Parameters
----------
proj_data_dir: Union[str, Path]
The path to the PROJ data directory.
"""
global _USER_PROJ_DATA
global _VALIDATED_PROJ_DATA
_USER_PROJ_DATA = str(proj_data_dir)
# set to none to re-validate
_VALIDATED_PROJ_DATA = None
# need to reset the global PROJ context
# to prevent core dumping if the data directory
# is not found.
_global_context_set_data_dir()
def append_data_dir(proj_data_dir: Union[str, Path]) -> None:
"""
Add an additional data directory for PROJ to use.
Parameters
----------
proj_data_dir: Union[str, Path]
The path to the PROJ data directory.
"""
set_data_dir(os.pathsep.join([get_data_dir(), str(proj_data_dir)]))
def get_data_dir() -> str:
"""
The order of preference for the data directory is:
1. The one set by pyproj.datadir.set_data_dir (if exists & valid)
2. The internal proj directory (if exists & valid)
3. The directory in PROJ_DATA (PROJ 9.1+) | PROJ_LIB (PROJ<9.1) (if exists & valid)
4. The directory on sys.prefix (if exists & valid)
5. The directory on the PATH (if exists & valid)
Returns
-------
str:
The valid data directory.
"""
# to avoid re-validating
global _VALIDATED_PROJ_DATA
if _VALIDATED_PROJ_DATA is not None:
return _VALIDATED_PROJ_DATA
internal_datadir = Path(__file__).absolute().parent / "proj_dir" / "share" / "proj"
proj_lib_dirs = os.environ.get("PROJ_DATA", os.environ.get("PROJ_LIB", ""))
prefix_datadir = Path(sys.prefix, "share", "proj")
conda_windows_prefix_datadir = Path(sys.prefix, "Library", "share", "proj")
def valid_data_dir(potential_data_dir):
if (
potential_data_dir is not None
and Path(potential_data_dir, "proj.db").exists()
):
return True
return False
def valid_data_dirs(potential_data_dirs):
if potential_data_dirs is None:
return False
for proj_data_dir in potential_data_dirs.split(os.pathsep):
if valid_data_dir(proj_data_dir):
return True
return None
if valid_data_dirs(_USER_PROJ_DATA):
_VALIDATED_PROJ_DATA = _USER_PROJ_DATA
elif valid_data_dir(internal_datadir):
_VALIDATED_PROJ_DATA = str(internal_datadir)
elif valid_data_dirs(proj_lib_dirs):
_VALIDATED_PROJ_DATA = proj_lib_dirs
elif valid_data_dir(prefix_datadir):
_VALIDATED_PROJ_DATA = str(prefix_datadir)
elif valid_data_dir(conda_windows_prefix_datadir):
_VALIDATED_PROJ_DATA = str(conda_windows_prefix_datadir)
else:
proj_exe = shutil.which("proj", path=sys.prefix)
if proj_exe is None:
proj_exe = shutil.which("proj")
if proj_exe is not None:
system_proj_dir = Path(proj_exe).parent.parent / "share" / "proj"
if valid_data_dir(system_proj_dir):
_VALIDATED_PROJ_DATA = str(system_proj_dir)
if _VALIDATED_PROJ_DATA is None:
raise DataDirError(
"Valid PROJ data directory not found. "
"Either set the path using the environmental variable "
"PROJ_DATA (PROJ 9.1+) | PROJ_LIB (PROJ<9.1) or "
"with `pyproj.datadir.set_data_dir`."
)
return _VALIDATED_PROJ_DATA
pyproj-3.6.1/pyproj/enums.py 0000664 0000000 0000000 00000007773 14502715416 0016113 0 ustar 00root root 0000000 0000000 """
This module contains enumerations used in pyproj.
"""
from enum import Enum, IntFlag
class BaseEnum(Enum):
"""
Base enumeration class that handles
input as strings ignoring case.
"""
@classmethod
def create(cls, item):
"""
Handles finding the enumeration
ignoring case if provided as a string.
"""
try:
return cls(item)
except ValueError:
pass
if isinstance(item, str):
item = item.upper()
for member in cls:
if member.value == item:
return member
raise ValueError(
f"Invalid value supplied '{item}'. "
f"Only {tuple(version.value for version in cls)} are supported."
)
class WktVersion(BaseEnum):
"""
.. versionadded:: 2.2.0
Supported CRS WKT string versions
See: :c:enum:`PJ_WKT_TYPE`
"""
#: WKT Version 2 from 2015
WKT2_2015 = "WKT2_2015"
#: WKT Version 2 from 2015 Simplified
WKT2_2015_SIMPLIFIED = "WKT2_2015_SIMPLIFIED"
#: Deprecated alias for WKT Version 2 from 2019
WKT2_2018 = "WKT2_2018"
#: Deprecated alias for WKT Version 2 from 2019 Simplified
WKT2_2018_SIMPLIFIED = "WKT2_2018_SIMPLIFIED"
#: WKT Version 2 from 2019
WKT2_2019 = "WKT2_2019"
#: WKT Version 2 from 2019 Simplified
WKT2_2019_SIMPLIFIED = "WKT2_2019_SIMPLIFIED"
#: WKT Version 1 GDAL Style
WKT1_GDAL = "WKT1_GDAL"
#: WKT Version 1 ESRI Style
WKT1_ESRI = "WKT1_ESRI"
class ProjVersion(BaseEnum):
"""
.. versionadded:: 2.2.0
Supported CRS PROJ string versions
"""
#: PROJ String version 4
PROJ_4 = 4
#: PROJ String version 5
PROJ_5 = 5
class TransformDirection(BaseEnum):
"""
.. versionadded:: 2.2.0
Supported transform directions
"""
#: Forward direction
FORWARD = "FORWARD"
#: Inverse direction
INVERSE = "INVERSE"
#: Do nothing
IDENT = "IDENT"
class PJType(BaseEnum):
"""
.. versionadded:: 2.4.0
PJ Types for listing codes with :func:`pyproj.get_codes`
See: :c:enum:`PJ_TYPE`
Attributes
----------
UNKNOWN
ELLIPSOID
PRIME_MERIDIAN
GEODETIC_REFERENCE_FRAME
DYNAMIC_GEODETIC_REFERENCE_FRAME
VERTICAL_REFERENCE_FRAME
DYNAMIC_VERTICAL_REFERENCE_FRAME
DATUM_ENSEMBLE
CRS
GEODETIC_CRS
GEOCENTRIC_CRS
GEOGRAPHIC_CRS
GEOGRAPHIC_2D_CRS
GEOGRAPHIC_3D_CRS
VERTICAL_CRS
PROJECTED_CRS
COMPOUND_CRS
TEMPORAL_CRS
ENGINEERING_CRS
BOUND_CRS
OTHER_CRS
CONVERSION
TRANSFORMATION
CONCATENATED_OPERATION
OTHER_COORDINATE_OPERATION
"""
UNKNOWN = "UNKNOWN"
ELLIPSOID = "ELLIPSOID"
PRIME_MERIDIAN = "PRIME_MERIDIAN"
GEODETIC_REFERENCE_FRAME = "GEODETIC_REFERENCE_FRAME"
DYNAMIC_GEODETIC_REFERENCE_FRAME = "DYNAMIC_GEODETIC_REFERENCE_FRAME"
VERTICAL_REFERENCE_FRAME = "VERTICAL_REFERENCE_FRAME"
DYNAMIC_VERTICAL_REFERENCE_FRAME = "DYNAMIC_VERTICAL_REFERENCE_FRAME"
DATUM_ENSEMBLE = "DATUM_ENSEMBLE"
CRS = "CRS"
GEODETIC_CRS = "GEODETIC_CRS"
GEOCENTRIC_CRS = "GEOCENTRIC_CRS"
GEOGRAPHIC_CRS = "GEOGRAPHIC_CRS"
GEOGRAPHIC_2D_CRS = "GEOGRAPHIC_2D_CRS"
GEOGRAPHIC_3D_CRS = "GEOGRAPHIC_3D_CRS"
VERTICAL_CRS = "VERTICAL_CRS"
PROJECTED_CRS = "PROJECTED_CRS"
DERIVED_PROJECTED_CRS = "DERIVED_PROJECTED_CRS"
COMPOUND_CRS = "COMPOUND_CRS"
TEMPORAL_CRS = "TEMPORAL_CRS"
ENGINEERING_CRS = "ENGINEERING_CRS"
BOUND_CRS = "BOUND_CRS"
OTHER_CRS = "OTHER_CRS"
CONVERSION = "CONVERSION"
TRANSFORMATION = "TRANSFORMATION"
CONCATENATED_OPERATION = "CONCATENATED_OPERATION"
OTHER_COORDINATE_OPERATION = "OTHER_COORDINATE_OPERATION"
class GeodIntermediateFlag(IntFlag):
"""
.. versionadded:: 3.1.0
Flags to be used in Geod.[inv|fwd]_intermediate()
"""
DEFAULT = 0x0
NPTS_ROUND = 0x0
NPTS_CEIL = 0x1
NPTS_TRUNC = 0x2
DEL_S_RECALC = 0x00
DEL_S_NO_RECALC = 0x10
AZIS_DISCARD = 0x000
AZIS_KEEP = 0x100
pyproj-3.6.1/pyproj/exceptions.py 0000664 0000000 0000000 00000001265 14502715416 0017133 0 ustar 00root root 0000000 0000000 """
Exceptions for pyproj
"""
from pyproj._datadir import _clear_proj_error, _get_proj_error
class ProjError(RuntimeError):
"""Raised when a Proj error occurs."""
def __init__(self, error_message: str) -> None:
proj_error = _get_proj_error()
if proj_error is not None:
error_message = f"{error_message}: (Internal Proj Error: {proj_error})"
_clear_proj_error()
super().__init__(error_message)
class CRSError(ProjError):
"""Raised when a CRS error occurs."""
class GeodError(RuntimeError):
"""Raised when a Geod error occurs."""
class DataDirError(RuntimeError):
"""Raised when a the data directory was not found."""
pyproj-3.6.1/pyproj/geod.py 0000664 0000000 0000000 00000126054 14502715416 0015674 0 ustar 00root root 0000000 0000000 """
The Geod class can perform forward and inverse geodetic, or
Great Circle, computations. The forward computation involves
determining latitude, longitude and back azimuth of a terminus
point given the latitude and longitude of an initial point, plus
azimuth and distance. The inverse computation involves
determining the forward and back azimuths and distance given the
latitudes and longitudes of an initial and terminus point.
"""
__all__ = [
"Geod",
"pj_ellps",
"geodesic_version_str",
"GeodIntermediateFlag",
"GeodIntermediateReturn",
"reverse_azimuth",
]
import math
import warnings
from typing import Any, Optional, Union
from pyproj._geod import Geod as _Geod
from pyproj._geod import GeodIntermediateReturn, geodesic_version_str
from pyproj._geod import reverse_azimuth as _reverse_azimuth
from pyproj.enums import GeodIntermediateFlag
from pyproj.exceptions import GeodError
from pyproj.list import get_ellps_map
from pyproj.utils import DataType, _convertback, _copytobuffer
pj_ellps = get_ellps_map()
def _params_from_ellps_map(ellps: str) -> tuple[float, float, float, float, bool]:
"""
Build Geodesic parameters from PROJ ellips map
Parameter
---------
ellps: str
The name of the ellipse in the map.
Returns
-------
tuple[float, float, float, float, bool]
"""
ellps_dict = pj_ellps[ellps]
semi_major_axis: float = ellps_dict["a"]
sphere = False
if ellps_dict["description"] == "Normal Sphere":
sphere = True
if "b" in ellps_dict:
semi_minor_axis: float = ellps_dict["b"]
eccentricity_squared: float = 1.0 - semi_minor_axis**2 / semi_major_axis**2
flattening: float = (semi_major_axis - semi_minor_axis) / semi_major_axis
elif "rf" in ellps_dict:
flattening = 1.0 / ellps_dict["rf"]
semi_minor_axis = semi_major_axis * (1.0 - flattening)
eccentricity_squared = 1.0 - semi_minor_axis**2 / semi_major_axis**2
return semi_major_axis, semi_minor_axis, flattening, eccentricity_squared, sphere
def _params_from_kwargs(kwargs: dict) -> tuple[float, float, float, float]:
"""
Build Geodesic parameters from input kwargs:
- a: the semi-major axis (required).
Need least one of these parameters.
- b: the semi-minor axis
- rf: the reciprocal flattening
- f: flattening
- es: eccentricity squared
Parameter
---------
kwargs: dict
The input kwargs for an ellipse.
Returns
-------
tuple[float, float, float, float]
"""
semi_major_axis = kwargs["a"]
if "b" in kwargs:
semi_minor_axis = kwargs["b"]
eccentricity_squared = 1.0 - semi_minor_axis**2 / semi_major_axis**2
flattening = (semi_major_axis - semi_minor_axis) / semi_major_axis
elif "rf" in kwargs:
flattening = 1.0 / kwargs["rf"]
semi_minor_axis = semi_major_axis * (1.0 - flattening)
eccentricity_squared = 1.0 - semi_minor_axis**2 / semi_major_axis**2
elif "f" in kwargs:
flattening = kwargs["f"]
semi_minor_axis = semi_major_axis * (1.0 - flattening)
eccentricity_squared = 1.0 - (semi_minor_axis / semi_major_axis) ** 2
elif "es" in kwargs:
eccentricity_squared = kwargs["es"]
semi_minor_axis = math.sqrt(
semi_major_axis**2 - eccentricity_squared * semi_major_axis**2
)
flattening = (semi_major_axis - semi_minor_axis) / semi_major_axis
elif "e" in kwargs:
eccentricity_squared = kwargs["e"] ** 2
semi_minor_axis = math.sqrt(
semi_major_axis**2 - eccentricity_squared * semi_major_axis**2
)
flattening = (semi_major_axis - semi_minor_axis) / semi_major_axis
else:
semi_minor_axis = semi_major_axis
flattening = 0.0
eccentricity_squared = 0.0
return semi_major_axis, semi_minor_axis, flattening, eccentricity_squared
class Geod(_Geod):
"""
performs forward and inverse geodetic, or Great Circle,
computations. The forward computation (using the 'fwd' method)
involves determining latitude, longitude and back azimuth of a
terminus point given the latitude and longitude of an initial
point, plus azimuth and distance. The inverse computation (using
the 'inv' method) involves determining the forward and back
azimuths and distance given the latitudes and longitudes of an
initial and terminus point.
Attributes
----------
initstring: str
The string form of the user input used to create the Geod.
sphere: bool
If True, it is a sphere.
a: float
The ellipsoid equatorial radius, or semi-major axis.
b: float
The ellipsoid polar radius, or semi-minor axis.
es: float
The 'eccentricity' of the ellipse, squared (1-b2/a2).
f: float
The ellipsoid 'flattening' parameter ( (a-b)/a ).
"""
def __init__(self, initstring: Optional[str] = None, **kwargs) -> None:
"""
initialize a Geod class instance.
Geodetic parameters for specifying the ellipsoid
can be given in a dictionary 'initparams', as keyword arguments,
or as as proj geod initialization string.
You can get a dictionary of ellipsoids using :func:`pyproj.get_ellps_map`
or with the variable `pyproj.pj_ellps`.
The parameters of the ellipsoid may also be set directly using
the 'a' (semi-major or equatorial axis radius) keyword, and
any one of the following keywords: 'b' (semi-minor,
or polar axis radius), 'e' (eccentricity), 'es' (eccentricity
squared), 'f' (flattening), or 'rf' (reciprocal flattening).
See the proj documentation (https://proj.org) for more
information about specifying ellipsoid parameters.
Example usage:
>>> from pyproj import Geod
>>> g = Geod(ellps='clrk66') # Use Clarke 1866 ellipsoid.
>>> # specify the lat/lons of some cities.
>>> boston_lat = 42.+(15./60.); boston_lon = -71.-(7./60.)
>>> portland_lat = 45.+(31./60.); portland_lon = -123.-(41./60.)
>>> newyork_lat = 40.+(47./60.); newyork_lon = -73.-(58./60.)
>>> london_lat = 51.+(32./60.); london_lon = -(5./60.)
>>> # compute forward and back azimuths, plus distance
>>> # between Boston and Portland.
>>> az12,az21,dist = g.inv(boston_lon,boston_lat,portland_lon,portland_lat)
>>> f"{az12:.3f} {az21:.3f} {dist:.3f}"
'-66.531 75.654 4164192.708'
>>> # compute latitude, longitude and back azimuth of Portland,
>>> # given Boston lat/lon, forward azimuth and distance to Portland.
>>> endlon, endlat, backaz = g.fwd(boston_lon, boston_lat, az12, dist)
>>> f"{endlat:.3f} {endlon:.3f} {backaz:.3f}"
'45.517 -123.683 75.654'
>>> # compute the azimuths, distances from New York to several
>>> # cities (pass a list)
>>> lons1 = 3*[newyork_lon]; lats1 = 3*[newyork_lat]
>>> lons2 = [boston_lon, portland_lon, london_lon]
>>> lats2 = [boston_lat, portland_lat, london_lat]
>>> az12,az21,dist = g.inv(lons1,lats1,lons2,lats2)
>>> for faz, baz, d in list(zip(az12,az21,dist)):
... f"{faz:7.3f} {baz:8.3f} {d:12.3f}"
' 54.663 -123.448 288303.720'
'-65.463 79.342 4013037.318'
' 51.254 -71.576 5579916.651'
>>> g2 = Geod('+ellps=clrk66') # use proj4 style initialization string
>>> az12,az21,dist = g2.inv(boston_lon,boston_lat,portland_lon,portland_lat)
>>> f"{az12:.3f} {az21:.3f} {dist:.3f}"
'-66.531 75.654 4164192.708'
"""
# if initparams is a proj-type init string,
# convert to dict.
ellpsd: dict[str, Union[str, float]] = {}
if initstring is not None:
for kvpair in initstring.split():
# Actually only +a and +b are needed
# We can ignore safely any parameter that doesn't have a value
if kvpair.find("=") == -1:
continue
key, val = kvpair.split("=")
key = key.lstrip("+")
if key in ["a", "b", "rf", "f", "es", "e"]:
ellpsd[key] = float(val)
else:
ellpsd[key] = val
# merge this dict with kwargs dict.
kwargs = dict(list(kwargs.items()) + list(ellpsd.items()))
sphere = False
if "ellps" in kwargs:
(
semi_major_axis,
semi_minor_axis,
flattening,
eccentricity_squared,
sphere,
) = _params_from_ellps_map(kwargs["ellps"])
else:
(
semi_major_axis,
semi_minor_axis,
flattening,
eccentricity_squared,
) = _params_from_kwargs(kwargs)
if math.fabs(flattening) < 1.0e-8:
sphere = True
super().__init__(
semi_major_axis, flattening, sphere, semi_minor_axis, eccentricity_squared
)
def fwd( # pylint: disable=invalid-name
self,
lons: Any,
lats: Any,
az: Any,
dist: Any,
radians: bool = False,
inplace: bool = False,
return_back_azimuth: bool = True,
) -> tuple[Any, Any, Any]:
"""
Forward transformation
Determine longitudes, latitudes and back azimuths of terminus
points given longitudes and latitudes of initial points,
plus forward azimuths and distances.
.. versionadded:: 3.5.0 inplace
.. versionadded:: 3.5.0 return_back_azimuth
Accepted numeric scalar or array:
- :class:`int`
- :class:`float`
- :class:`numpy.floating`
- :class:`numpy.integer`
- :class:`list`
- :class:`tuple`
- :class:`array.array`
- :class:`numpy.ndarray`
- :class:`xarray.DataArray`
- :class:`pandas.Series`
Parameters
----------
lons: scalar or array
Longitude(s) of initial point(s)
lats: scalar or array
Latitude(s) of initial point(s)
az: scalar or array
Forward azimuth(s)
dist: scalar or array
Distance(s) between initial and terminus point(s)
in meters
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
inplace: bool, default=False
If True, will attempt to write the results to the input array
instead of returning a new array. This will fail if the input
is not an array in C order with the double data type.
return_back_azimuth: bool, default=True
If True, the third return value will be the back azimuth,
Otherwise, it will be the forward azimuth.
Returns
-------
scalar or array:
Longitude(s) of terminus point(s)
scalar or array:
Latitude(s) of terminus point(s)
scalar or array:
Back azimuth(s) or Forward azimuth(s)
"""
try:
# Fast-path for scalar input, will raise if invalid types are input
# and we can fallback below
return self._fwd_point(
lons,
lats,
az,
dist,
radians=radians,
return_back_azimuth=return_back_azimuth,
)
except TypeError:
pass
# process inputs, making copies that support buffer API.
inx, x_data_type = _copytobuffer(lons, inplace=inplace)
iny, y_data_type = _copytobuffer(lats, inplace=inplace)
inz, z_data_type = _copytobuffer(az, inplace=inplace)
ind = _copytobuffer(dist, inplace=inplace)[0]
self._fwd(
inx, iny, inz, ind, radians=radians, return_back_azimuth=return_back_azimuth
)
# if inputs were lists, tuples or floats, convert back.
outx = _convertback(x_data_type, inx)
outy = _convertback(y_data_type, iny)
outz = _convertback(z_data_type, inz)
return outx, outy, outz
def inv(
self,
lons1: Any,
lats1: Any,
lons2: Any,
lats2: Any,
radians: bool = False,
inplace: bool = False,
return_back_azimuth: bool = True,
) -> tuple[Any, Any, Any]:
"""
Inverse transformation
Determine forward and back azimuths, plus distances
between initial points and terminus points.
.. versionadded:: 3.5.0 inplace
.. versionadded:: 3.5.0 return_back_azimuth
Accepted numeric scalar or array:
- :class:`int`
- :class:`float`
- :class:`numpy.floating`
- :class:`numpy.integer`
- :class:`list`
- :class:`tuple`
- :class:`array.array`
- :class:`numpy.ndarray`
- :class:`xarray.DataArray`
- :class:`pandas.Series`
Parameters
----------
lons1: scalar or array
Longitude(s) of initial point(s)
lats1: scalar or array
Latitude(s) of initial point(s)
lons2: scalar or array
Longitude(s) of terminus point(s)
lats2: scalar or array
Latitude(s) of terminus point(s)
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
inplace: bool, default=False
If True, will attempt to write the results to the input array
instead of returning a new array. This will fail if the input
is not an array in C order with the double data type.
return_back_azimuth: bool, default=True
If True, the second return value (azi21) will be the back azimuth
(flipped 180 degrees), Otherwise, it will also be a forward azimuth.
Returns
-------
scalar or array:
Forward azimuth(s) (azi12)
scalar or array:
Back azimuth(s) or Forward azimuth(s) (azi21)
scalar or array:
Distance(s) between initial and terminus point(s)
in meters
"""
try:
# Fast-path for scalar input, will raise if invalid types are input
# and we can fallback below
return self._inv_point(
lons1,
lats1,
lons2,
lats2,
radians=radians,
return_back_azimuth=return_back_azimuth,
)
except TypeError:
pass
# process inputs, making copies that support buffer API.
inx, x_data_type = _copytobuffer(lons1, inplace=inplace)
iny, y_data_type = _copytobuffer(lats1, inplace=inplace)
inz, z_data_type = _copytobuffer(lons2, inplace=inplace)
ind = _copytobuffer(lats2, inplace=inplace)[0]
self._inv(
inx, iny, inz, ind, radians=radians, return_back_azimuth=return_back_azimuth
)
# if inputs were lists, tuples or floats, convert back.
outx = _convertback(x_data_type, inx)
outy = _convertback(y_data_type, iny)
outz = _convertback(z_data_type, inz)
return outx, outy, outz
def npts(
self,
lon1: float,
lat1: float,
lon2: float,
lat2: float,
npts: int,
radians: bool = False,
initial_idx: int = 1,
terminus_idx: int = 1,
) -> list:
"""
.. versionadded:: 3.1.0 initial_idx, terminus_idx
Given a single initial point and terminus point, returns
a list of longitude/latitude pairs describing npts equally
spaced intermediate points along the geodesic between the
initial and terminus points.
Similar to inv_intermediate(), but with less options.
Example usage:
>>> from pyproj import Geod
>>> g = Geod(ellps='clrk66') # Use Clarke 1866 ellipsoid.
>>> # specify the lat/lons of Boston and Portland.
>>> boston_lat = 42.+(15./60.); boston_lon = -71.-(7./60.)
>>> portland_lat = 45.+(31./60.); portland_lon = -123.-(41./60.)
>>> # find ten equally spaced points between Boston and Portland.
>>> lonlats = g.npts(boston_lon,boston_lat,portland_lon,portland_lat,10)
>>> for lon,lat in lonlats: f'{lat:.3f} {lon:.3f}'
'43.528 -75.414'
'44.637 -79.883'
'45.565 -84.512'
'46.299 -89.279'
'46.830 -94.156'
'47.149 -99.112'
'47.251 -104.106'
'47.136 -109.100'
'46.805 -114.051'
'46.262 -118.924'
>>> # test with radians=True (inputs/outputs in radians, not degrees)
>>> import math
>>> dg2rad = math.radians(1.)
>>> rad2dg = math.degrees(1.)
>>> lonlats = g.npts(
... dg2rad*boston_lon,
... dg2rad*boston_lat,
... dg2rad*portland_lon,
... dg2rad*portland_lat,
... 10,
... radians=True
... )
>>> for lon,lat in lonlats: f'{rad2dg*lat:.3f} {rad2dg*lon:.3f}'
'43.528 -75.414'
'44.637 -79.883'
'45.565 -84.512'
'46.299 -89.279'
'46.830 -94.156'
'47.149 -99.112'
'47.251 -104.106'
'47.136 -109.100'
'46.805 -114.051'
'46.262 -118.924'
Parameters
----------
lon1: float
Longitude of the initial point
lat1: float
Latitude of the initial point
lon2: float
Longitude of the terminus point
lat2: float
Latitude of the terminus point
npts: int
Number of points to be returned
(including initial and/or terminus points, if required)
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
initial_idx: int, default=1
if initial_idx==0 then the initial point would be included in the output
(as the first point)
terminus_idx: int, default=1
if terminus_idx==0 then the terminus point would be included in the output
(as the last point)
Returns
-------
list of tuples:
list of (lon, lat) points along the geodesic
between the initial and terminus points.
"""
res = self._inv_or_fwd_intermediate(
lon1=lon1,
lat1=lat1,
lon2_or_azi1=lon2,
lat2=lat2,
npts=npts,
del_s=0,
radians=radians,
initial_idx=initial_idx,
terminus_idx=terminus_idx,
flags=GeodIntermediateFlag.AZIS_DISCARD,
out_lons=None,
out_lats=None,
out_azis=None,
return_back_azimuth=False,
is_fwd=False,
)
return list(zip(res.lons, res.lats))
def inv_intermediate(
self,
lon1: float,
lat1: float,
lon2: float,
lat2: float,
npts: int = 0,
del_s: float = 0,
initial_idx: int = 1,
terminus_idx: int = 1,
radians: bool = False,
flags: GeodIntermediateFlag = GeodIntermediateFlag.DEFAULT,
out_lons: Optional[Any] = None,
out_lats: Optional[Any] = None,
out_azis: Optional[Any] = None,
return_back_azimuth: Optional[bool] = None,
) -> GeodIntermediateReturn:
"""
.. versionadded:: 3.1.0
.. versionadded:: 3.5.0 return_back_azimuth
Given a single initial point and terminus point,
and the number of points, returns
a list of longitude/latitude pairs describing npts equally
spaced intermediate points along the geodesic between the
initial and terminus points.
npts and del_s parameters are mutually exclusive:
if npts != 0:
it calculates the distance between the points by
the distance between the initial point and the
terminus point divided by npts
(the number of intermediate points)
else:
it calculates the number of intermediate points by
dividing the distance between the initial and
terminus points by del_s
(delimiter distance between two successive points)
Similar to npts(), but with more options.
Example usage:
>>> from pyproj import Geod
>>> g = Geod(ellps='clrk66') # Use Clarke 1866 ellipsoid.
>>> # specify the lat/lons of Boston and Portland.
>>> boston_lat = 42.+(15./60.); boston_lon = -71.-(7./60.)
>>> portland_lat = 45.+(31./60.); portland_lon = -123.-(41./60.)
>>> # find ten equally spaced points between Boston and Portland.
>>> r = g.inv_intermediate(boston_lon,boston_lat,portland_lon,portland_lat,10)
>>> for lon,lat in zip(r.lons, r.lats): f'{lat:.3f} {lon:.3f}'
'43.528 -75.414'
'44.637 -79.883'
'45.565 -84.512'
'46.299 -89.279'
'46.830 -94.156'
'47.149 -99.112'
'47.251 -104.106'
'47.136 -109.100'
'46.805 -114.051'
'46.262 -118.924'
>>> # test with radians=True (inputs/outputs in radians, not degrees)
>>> import math
>>> dg2rad = math.radians(1.)
>>> rad2dg = math.degrees(1.)
>>> r = g.inv_intermediate(
... dg2rad*boston_lon,
... dg2rad*boston_lat,
... dg2rad*portland_lon,
... dg2rad*portland_lat,
... 10,
... radians=True
... )
>>> for lon,lat in zip(r.lons, r.lats): f'{rad2dg*lat:.3f} {rad2dg*lon:.3f}'
'43.528 -75.414'
'44.637 -79.883'
'45.565 -84.512'
'46.299 -89.279'
'46.830 -94.156'
'47.149 -99.112'
'47.251 -104.106'
'47.136 -109.100'
'46.805 -114.051'
'46.262 -118.924'
Parameters
----------
lon1: float
Longitude of the initial point
lat1: float
Latitude of the initial point
lon2: float
Longitude of the terminus point
lat2: float
Latitude of the terminus point
npts: int, default=0
Number of points to be returned
npts == 0 if del_s != 0
del_s: float, default=0
delimiter distance between two successive points
del_s == 0 if npts != 0
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
initial_idx: int, default=1
if initial_idx==0 then the initial point would be included in the output
(as the first point)
terminus_idx: int, default=1
if terminus_idx==0 then the terminus point would be included in the output
(as the last point)
flags: GeodIntermediateFlag, default=GeodIntermediateFlag.DEFAULT
* 1st - round/ceil/trunc (see ``GeodIntermediateFlag.NPTS_*``)
* 2nd - update del_s to the new npts or not
(see ``GeodIntermediateFlag.DEL_S_*``)
* 3rd - if out_azis=None, indicates if to save or discard the azimuths
(see ``GeodIntermediateFlag.AZIS_*``)
* default - round npts, update del_s accordingly, discard azis
out_lons: array, :class:`numpy.ndarray`, optional
Longitude(s) of the intermediate point(s)
If None then buffers would be allocated internnaly
out_lats: array, :class:`numpy.ndarray`, optional
Latitudes(s) of the intermediate point(s)
If None then buffers would be allocated internnaly
out_azis: array, :class:`numpy.ndarray`, optional
az12(s) of the intermediate point(s)
If None then buffers would be allocated internnaly
unless requested otherwise by the flags
return_back_azimuth: bool, default=True
if True, out_azis will store the back azimuth,
Otherwise, out_azis will store the forward azimuth.
Returns
-------
GeodIntermediateReturn:
number of points, distance and output arrays (GeodIntermediateReturn docs)
"""
if return_back_azimuth is None:
return_back_azimuth = True
warnings.warn(
"Back azimuth is being returned by default to be compatible with fwd()"
"This is a breaking change for pyproj 3.5+."
"To avoid this warning, set return_back_azimuth=True."
"Otherwise, to restore old behaviour, set return_back_azimuth=False."
"This warning will be removed in future version."
)
return super()._inv_or_fwd_intermediate(
lon1=lon1,
lat1=lat1,
lon2_or_azi1=lon2,
lat2=lat2,
npts=npts,
del_s=del_s,
radians=radians,
initial_idx=initial_idx,
terminus_idx=terminus_idx,
flags=int(flags),
out_lons=out_lons,
out_lats=out_lats,
out_azis=out_azis,
return_back_azimuth=return_back_azimuth,
is_fwd=False,
)
def fwd_intermediate(
self,
lon1: float,
lat1: float,
azi1: float,
npts: int,
del_s: float,
initial_idx: int = 1,
terminus_idx: int = 1,
radians: bool = False,
flags: GeodIntermediateFlag = GeodIntermediateFlag.DEFAULT,
out_lons: Optional[Any] = None,
out_lats: Optional[Any] = None,
out_azis: Optional[Any] = None,
return_back_azimuth: Optional[bool] = None,
) -> GeodIntermediateReturn:
"""
.. versionadded:: 3.1.0
.. versionadded:: 3.5.0 return_back_azimuth
Given a single initial point and azimuth, number of points (npts)
and delimiter distance between two successive points (del_s), returns
a list of longitude/latitude pairs describing npts equally
spaced intermediate points along the geodesic between the
initial and terminus points.
Example usage:
>>> from pyproj import Geod
>>> g = Geod(ellps='clrk66') # Use Clarke 1866 ellipsoid.
>>> # specify the lat/lons of Boston and Portland.
>>> boston_lat = 42.+(15./60.); boston_lon = -71.-(7./60.)
>>> portland_lat = 45.+(31./60.); portland_lon = -123.-(41./60.)
>>> az12,az21,dist = g.inv(boston_lon,boston_lat,portland_lon,portland_lat)
>>> # find ten equally spaced points between Boston and Portland.
>>> npts = 10
>>> del_s = dist/(npts+1)
>>> r = g.fwd_intermediate(boston_lon,boston_lat,az12,npts=npts,del_s=del_s)
>>> for lon,lat in zip(r.lons, r.lats): f'{lat:.3f} {lon:.3f}'
'43.528 -75.414'
'44.637 -79.883'
'45.565 -84.512'
'46.299 -89.279'
'46.830 -94.156'
'47.149 -99.112'
'47.251 -104.106'
'47.136 -109.100'
'46.805 -114.051'
'46.262 -118.924'
>>> # test with radians=True (inputs/outputs in radians, not degrees)
>>> import math
>>> dg2rad = math.radians(1.)
>>> rad2dg = math.degrees(1.)
>>> r = g.fwd_intermediate(
... dg2rad*boston_lon,
... dg2rad*boston_lat,
... dg2rad*az12,
... npts=npts,
... del_s=del_s,
... radians=True
... )
>>> for lon,lat in zip(r.lons, r.lats): f'{rad2dg*lat:.3f} {rad2dg*lon:.3f}'
'43.528 -75.414'
'44.637 -79.883'
'45.565 -84.512'
'46.299 -89.279'
'46.830 -94.156'
'47.149 -99.112'
'47.251 -104.106'
'47.136 -109.100'
'46.805 -114.051'
'46.262 -118.924'
Parameters
----------
lon1: float
Longitude of the initial point
lat1: float
Latitude of the initial point
azi1: float
Azimuth from the initial point towards the terminus point
npts: int
Number of points to be returned
(including initial and/or terminus points, if required)
del_s: float
delimiter distance between two successive points
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
initial_idx: int, default=1
if initial_idx==0 then the initial point would be included in the output
(as the first point)
terminus_idx: int, default=1
if terminus_idx==0 then the terminus point would be included in the output
(as the last point)
flags: GeodIntermediateFlag, default=GeodIntermediateFlag.DEFAULT
* 1st - round/ceil/trunc (see ``GeodIntermediateFlag.NPTS_*``)
* 2nd - update del_s to the new npts or not
(see ``GeodIntermediateFlag.DEL_S_*``)
* 3rd - if out_azis=None, indicates if to save or discard the azimuths
(see ``GeodIntermediateFlag.AZIS_*``)
* default - round npts, update del_s accordingly, discard azis
out_lons: array, :class:`numpy.ndarray`, optional
Longitude(s) of the intermediate point(s)
If None then buffers would be allocated internnaly
out_lats: array, :class:`numpy.ndarray`, optional
Latitudes(s) of the intermediate point(s)
If None then buffers would be allocated internnaly
out_azis: array, :class:`numpy.ndarray`, optional
az12(s) of the intermediate point(s)
If None then buffers would be allocated internnaly
unless requested otherwise by the flags
return_back_azimuth: bool, default=True
if True, out_azis will store the back azimuth,
Otherwise, out_azis will store the forward azimuth.
Returns
-------
GeodIntermediateReturn:
number of points, distance and output arrays (GeodIntermediateReturn docs)
"""
if return_back_azimuth is None:
return_back_azimuth = True
warnings.warn(
"Back azimuth is being returned by default to be compatible with inv()"
"This is a breaking change for pyproj 3.5+."
"To avoid this warning, set return_back_azimuth=True."
"Otherwise, to restore old behaviour, set return_back_azimuth=False."
"This warning will be removed in future version."
)
return super()._inv_or_fwd_intermediate(
lon1=lon1,
lat1=lat1,
lon2_or_azi1=azi1,
lat2=math.nan,
npts=npts,
del_s=del_s,
radians=radians,
initial_idx=initial_idx,
terminus_idx=terminus_idx,
flags=int(flags),
out_lons=out_lons,
out_lats=out_lats,
out_azis=out_azis,
return_back_azimuth=return_back_azimuth,
is_fwd=True,
)
def line_length(self, lons: Any, lats: Any, radians: bool = False) -> float:
"""
.. versionadded:: 2.3.0
Calculate the total distance between points along a line (meters).
>>> from pyproj import Geod
>>> geod = Geod('+a=6378137 +f=0.0033528106647475126')
>>> lats = [-72.9, -71.9, -74.9, -74.3, -77.5, -77.4, -71.7, -65.9, -65.7,
... -66.6, -66.9, -69.8, -70.0, -71.0, -77.3, -77.9, -74.7]
>>> lons = [-74, -102, -102, -131, -163, 163, 172, 140, 113,
... 88, 59, 25, -4, -14, -33, -46, -61]
>>> total_length = geod.line_length(lons, lats)
>>> f"{total_length:.3f}"
'14259605.611'
Parameters
----------
lons: array, :class:`numpy.ndarray`, list, tuple, or scalar
The longitude points along a line.
lats: array, :class:`numpy.ndarray`, list, tuple, or scalar
The latitude points along a line.
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
Returns
-------
float:
The total length of the line (meters).
"""
# process inputs, making copies that support buffer API.
inx = _copytobuffer(lons)[0]
iny = _copytobuffer(lats)[0]
return self._line_length(inx, iny, radians=radians)
def line_lengths(self, lons: Any, lats: Any, radians: bool = False) -> Any:
"""
.. versionadded:: 2.3.0
Calculate the distances between points along a line (meters).
>>> from pyproj import Geod
>>> geod = Geod(ellps="WGS84")
>>> lats = [-72.9, -71.9, -74.9]
>>> lons = [-74, -102, -102]
>>> for line_length in geod.line_lengths(lons, lats):
... f"{line_length:.3f}"
'943065.744'
'334805.010'
Parameters
----------
lons: array, :class:`numpy.ndarray`, list, tuple, or scalar
The longitude points along a line.
lats: array, :class:`numpy.ndarray`, list, tuple, or scalar
The latitude points along a line.
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
Returns
-------
array, :class:`numpy.ndarray`, list, tuple, or scalar:
The total length of the line (meters).
"""
# process inputs, making copies that support buffer API.
inx, x_data_type = _copytobuffer(lons)
iny = _copytobuffer(lats)[0]
self._line_length(inx, iny, radians=radians)
line_lengths = _convertback(x_data_type, inx)
return line_lengths if x_data_type == DataType.FLOAT else line_lengths[:-1]
def polygon_area_perimeter(
self, lons: Any, lats: Any, radians: bool = False
) -> tuple[float, float]:
"""
.. versionadded:: 2.3.0
A simple interface for computing the area (meters^2) and perimeter (meters)
of a geodesic polygon.
Arbitrarily complex polygons are allowed. In the case self-intersecting
of polygons the area is accumulated "algebraically", e.g., the areas of
the 2 loops in a figure-8 polygon will partially cancel. There's no need
to "close" the polygon by repeating the first vertex. The area returned
is signed with counter-clockwise traversal being treated as positive.
.. note:: lats should be in the range [-90 deg, 90 deg].
Example usage:
>>> from pyproj import Geod
>>> geod = Geod('+a=6378137 +f=0.0033528106647475126')
>>> lats = [-72.9, -71.9, -74.9, -74.3, -77.5, -77.4, -71.7, -65.9, -65.7,
... -66.6, -66.9, -69.8, -70.0, -71.0, -77.3, -77.9, -74.7]
>>> lons = [-74, -102, -102, -131, -163, 163, 172, 140, 113,
... 88, 59, 25, -4, -14, -33, -46, -61]
>>> poly_area, poly_perimeter = geod.polygon_area_perimeter(lons, lats)
>>> f"{poly_area:.1f} {poly_perimeter:.1f}"
'13376856682207.4 14710425.4'
Parameters
----------
lons: array, :class:`numpy.ndarray`, list, tuple, or scalar
An array of longitude values.
lats: array, :class:`numpy.ndarray`, list, tuple, or scalar
An array of latitude values.
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
Returns
-------
(float, float):
The geodesic area (meters^2) and perimeter (meters) of the polygon.
"""
return self._polygon_area_perimeter(
_copytobuffer(lons)[0], _copytobuffer(lats)[0], radians=radians
)
def geometry_length(self, geometry, radians: bool = False) -> float:
"""
.. versionadded:: 2.3.0
Returns the geodesic length (meters) of the shapely geometry.
If it is a Polygon, it will return the sum of the
lengths along the perimeter.
If it is a MultiPolygon or MultiLine, it will return
the sum of the lengths.
Example usage:
>>> from pyproj import Geod
>>> from shapely.geometry import Point, LineString
>>> line_string = LineString([Point(1, 2), Point(3, 4)])
>>> geod = Geod(ellps="WGS84")
>>> f"{geod.geometry_length(line_string):.3f}"
'313588.397'
Parameters
----------
geometry: :class:`shapely.geometry.BaseGeometry`
The geometry to calculate the length from.
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
Returns
-------
float:
The total geodesic length of the geometry (meters).
"""
try:
return self.line_length(*geometry.xy, radians=radians) # type: ignore
except (AttributeError, NotImplementedError):
pass
if hasattr(geometry, "exterior"):
return self.geometry_length(geometry.exterior, radians=radians)
if hasattr(geometry, "geoms"):
total_length = 0.0
for geom in geometry.geoms:
total_length += self.geometry_length(geom, radians=radians)
return total_length
raise GeodError("Invalid geometry provided.")
def geometry_area_perimeter(
self, geometry, radians: bool = False
) -> tuple[float, float]:
"""
.. versionadded:: 2.3.0
A simple interface for computing the area (meters^2) and perimeter (meters)
of a geodesic polygon as a shapely geometry.
Arbitrarily complex polygons are allowed. In the case self-intersecting
of polygons the area is accumulated "algebraically", e.g., the areas of
the 2 loops in a figure-8 polygon will partially cancel. There's no need
to "close" the polygon by repeating the first vertex.
.. note:: lats should be in the range [-90 deg, 90 deg].
.. warning:: The area returned is signed with counter-clockwise (CCW) traversal
being treated as positive. For polygons, holes should use the
opposite traversal to the exterior (if the exterior is CCW, the
holes/interiors should be CW). You can use `shapely.ops.orient` to
modify the orientation.
If it is a Polygon, it will return the area and exterior perimeter.
It will subtract the area of the interior holes.
If it is a MultiPolygon or MultiLine, it will return
the sum of the areas and perimeters of all geometries.
Example usage:
>>> from pyproj import Geod
>>> from shapely.geometry import LineString, Point, Polygon
>>> geod = Geod(ellps="WGS84")
>>> poly_area, poly_perimeter = geod.geometry_area_perimeter(
... Polygon(
... LineString([
... Point(1, 1), Point(10, 1), Point(10, 10), Point(1, 10)
... ]),
... holes=[LineString([Point(1, 2), Point(3, 4), Point(5, 2)])],
... )
... )
>>> f"{poly_area:.0f} {poly_perimeter:.0f}"
'944373881400 3979008'
Parameters
----------
geometry: :class:`shapely.geometry.BaseGeometry`
The geometry to calculate the area and perimeter from.
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
Returns
-------
(float, float):
The geodesic area (meters^2) and perimeter (meters) of the polygon.
"""
try:
return self.polygon_area_perimeter( # type: ignore
*geometry.xy, radians=radians
)
except (AttributeError, NotImplementedError):
pass
# polygon
if hasattr(geometry, "exterior"):
total_area, total_perimeter = self.geometry_area_perimeter(
geometry.exterior, radians=radians
)
# subtract area of holes
for hole in geometry.interiors:
area, _ = self.geometry_area_perimeter(hole, radians=radians)
total_area += area
return total_area, total_perimeter
# multi geometries
if hasattr(geometry, "geoms"):
total_area = 0.0
total_perimeter = 0.0
for geom in geometry.geoms:
area, perimeter = self.geometry_area_perimeter(geom, radians=radians)
total_area += area
total_perimeter += perimeter
return total_area, total_perimeter
raise GeodError("Invalid geometry provided.")
def __repr__(self) -> str:
# search for ellipse name
for ellps, vals in pj_ellps.items():
if self.a == vals["a"]:
# self.sphere is True when self.f is zero or very close to
# zero (0), so prevent divide by zero.
if self.b == vals.get("b") or (
not self.sphere and (1.0 / self.f) == vals.get("rf")
):
return f"{self.__class__.__name__}(ellps={ellps!r})"
# no ellipse name found, call super class
return super().__repr__()
def __eq__(self, other: Any) -> bool:
"""
equality operator == for Geod objects
Example usage:
>>> from pyproj import Geod
>>> # Use Clarke 1866 ellipsoid.
>>> gclrk1 = Geod(ellps='clrk66')
>>> # Define Clarke 1866 using parameters
>>> gclrk2 = Geod(a=6378206.4, b=6356583.8)
>>> gclrk1 == gclrk2
True
>>> # WGS 66 ellipsoid, PROJ style
>>> gwgs66 = Geod('+ellps=WGS66')
>>> # Naval Weapons Lab., 1965 ellipsoid
>>> gnwl9d = Geod('+ellps=NWL9D')
>>> # these ellipsoids are the same
>>> gnwl9d == gwgs66
True
>>> gclrk1 != gnwl9d # Clarke 1866 is unlike NWL9D
True
"""
if not isinstance(other, _Geod):
return False
return self.__repr__() == other.__repr__()
def reverse_azimuth(azi: Any, radians: bool = False) -> Any:
"""
Reverses the given azimuth (forward <-> backwards)
.. versionadded:: 3.5.0
Accepted numeric scalar or array:
- :class:`int`
- :class:`float`
- :class:`numpy.floating`
- :class:`numpy.integer`
- :class:`list`
- :class:`tuple`
- :class:`array.array`
- :class:`numpy.ndarray`
- :class:`xarray.DataArray`
- :class:`pandas.Series`
Parameters
----------
azi: scalar or array
The azimuth.
radians: bool, default=False
If True, the input data is assumed to be in radians.
Otherwise, the data is assumed to be in degrees.
Returns
-------
scalar or array:
The reversed azimuth (forward <-> backwards)
"""
inazi, azi_data_type = _copytobuffer(azi)
_reverse_azimuth(inazi, radians=radians)
return _convertback(azi_data_type, inazi)
pyproj-3.6.1/pyproj/list.pyi 0000664 0000000 0000000 00000000242 14502715416 0016070 0 ustar 00root root 0000000 0000000 def get_proj_operations_map() -> dict[str, str]: ...
def get_ellps_map() -> dict[str, dict[str, float]]: ...
def get_prime_meridians_map() -> dict[str, str]: ...
pyproj-3.6.1/pyproj/list.pyx 0000664 0000000 0000000 00000002707 14502715416 0016117 0 ustar 00root root 0000000 0000000 include "proj.pxi"
def get_proj_operations_map():
"""
Returns
-------
dict:
Operations supported by PROJ.
"""
cdef const PJ_OPERATIONS *proj_operations = proj_list_operations()
cdef int iii = 0
operations_map = {}
while proj_operations[iii].id != NULL:
operations_map[proj_operations[iii].id] = \
proj_operations[iii].descr[0].split("\n\t")[0]
iii += 1
return operations_map
def get_ellps_map():
"""
Returns
-------
dict:
Ellipsoids supported by PROJ.
"""
cdef const PJ_ELLPS *proj_ellps = proj_list_ellps()
cdef int iii = 0
ellps_map = {}
while proj_ellps[iii].id != NULL:
major_key, major_val = proj_ellps[iii].major.split("=")
ell_key, ell_val = proj_ellps[iii].ell.split("=")
ellps_map[proj_ellps[iii].id] = {
major_key: float(major_val),
ell_key: float(ell_val),
"description": proj_ellps[iii].name
}
iii += 1
return ellps_map
def get_prime_meridians_map():
"""
Returns
-------
dict:
Prime Meridians supported by PROJ.
"""
cdef const PJ_PRIME_MERIDIANS *prime_meridians = proj_list_prime_meridians()
cdef int iii = 0
prime_meridians_map = {}
while prime_meridians[iii].id != NULL:
prime_meridians_map[prime_meridians[iii].id] = \
prime_meridians[iii].defn
iii += 1
return prime_meridians_map
pyproj-3.6.1/pyproj/network.py 0000664 0000000 0000000 00000003573 14502715416 0016447 0 ustar 00root root 0000000 0000000 """
Module for managing the PROJ network settings.
"""
import os
from pathlib import Path
from typing import Union
import certifi
from pyproj._network import ( # noqa: F401 pylint: disable=unused-import
_set_ca_bundle_path,
is_network_enabled,
set_network_enabled,
)
def set_ca_bundle_path(ca_bundle_path: Union[Path, str, bool, None] = None) -> None:
"""
.. versionadded:: 3.0.0
Sets the path to the CA Bundle used by the `curl`
built into PROJ when PROJ network is enabled.
See: :c:func:`proj_context_set_ca_bundle_path`
Environment variables:
- PROJ_CURL_CA_BUNDLE
- CURL_CA_BUNDLE
- SSL_CERT_FILE
Parameters
----------
ca_bundle_path: Union[Path, str, bool, None], optional
Default is None, which only uses the `certifi` package path as a fallback if
the environment variables are not set. If a path is passed in, then
that will be the path used. If it is set to True, then it will default
to using the path provided, by the `certifi` package. If it is set to False
or an empty string then it will default to the system settings or environment
variables.
"""
env_var_names = ("PROJ_CURL_CA_BUNDLE", "CURL_CA_BUNDLE", "SSL_CERT_FILE")
if ca_bundle_path is False:
# need to reset CA Bundle path to use system settings
# or environment variables because it
# could have been changed by the user previously
ca_bundle_path = ""
elif isinstance(ca_bundle_path, (str, Path)):
ca_bundle_path = str(ca_bundle_path)
elif (ca_bundle_path is True) or not any(
env_var_name in os.environ for env_var_name in env_var_names
):
ca_bundle_path = certifi.where()
else:
# reset CA Bundle path to use system settings
# or environment variables
ca_bundle_path = ""
_set_ca_bundle_path(ca_bundle_path)
pyproj-3.6.1/pyproj/proj.pxi 0000664 0000000 0000000 00000051507 14502715416 0016100 0 ustar 00root root 0000000 0000000 # PROJ API Definition
cdef extern from "proj.h" nogil:
cdef int PROJ_VERSION_MAJOR
cdef int PROJ_VERSION_MINOR
cdef int PROJ_VERSION_PATCH
void proj_context_set_search_paths(
PJ_CONTEXT *ctx, int count_paths, const char* const* paths)
int proj_context_set_database_path(PJ_CONTEXT *ctx,
const char *dbPath,
const char *const *auxDbPaths,
const char* const *options)
void proj_context_set_ca_bundle_path(PJ_CONTEXT *ctx, const char *path)
const char *proj_context_get_database_metadata(PJ_CONTEXT* ctx,
const char* key)
ctypedef struct PJ
ctypedef struct PJ_CONTEXT
PJ_CONTEXT *proj_context_create ()
PJ_CONTEXT *proj_context_clone (PJ_CONTEXT *ctx)
PJ_CONTEXT *proj_context_destroy (PJ_CONTEXT *ctx)
void proj_assign_context(PJ* pj, PJ_CONTEXT* ctx)
ctypedef enum PJ_LOG_LEVEL:
PJ_LOG_NONE
PJ_LOG_ERROR
PJ_LOG_DEBUG
PJ_LOG_TRACE
PJ_LOG_TELL
ctypedef void (*PJ_LOG_FUNCTION)(void *, int, const char *)
void proj_log_func (PJ_CONTEXT *ctx, void *app_data, PJ_LOG_FUNCTION logf)
int proj_errno (const PJ *P)
const char * proj_context_errno_string(PJ_CONTEXT* ctx, int err)
int proj_errno_reset (const PJ *P)
PJ *proj_create (PJ_CONTEXT *ctx, const char *definition)
PJ *proj_normalize_for_visualization(PJ_CONTEXT *ctx, const PJ* obj)
ctypedef struct PJ_PROJ_INFO:
const char *id
const char *description
const char *definition
int has_inverse #1 if an inverse mapping exists, 0 otherwise */
double accuracy
PJ_PROJ_INFO proj_pj_info(PJ *P)
ctypedef struct PJ_XYZT:
double x, y, z, t
ctypedef struct PJ_UVWT:
double u, v, w, t
ctypedef struct PJ_LPZT:
double lam, phi, z, t
ctypedef struct PJ_OPK:
double o, p, k
ctypedef struct PJ_ENU:
double e, n, u
ctypedef struct PJ_GEOD:
double s, a1, a2
ctypedef struct PJ_UV:
double u, v
ctypedef struct PJ_XY:
double x, y
ctypedef struct PJ_LP:
double lam, phi
ctypedef struct PJ_XYZ:
double x, y, z
ctypedef struct PJ_UVW:
double u, v, w
ctypedef struct PJ_LPZ:
double lam, phi, z
ctypedef union PJ_COORD:
double v[4];
PJ_XYZT xyzt;
PJ_UVWT uvwt;
PJ_LPZT lpzt;
PJ_GEOD geod;
PJ_OPK opk;
PJ_ENU enu;
PJ_XYZ xyz;
PJ_UVW uvw;
PJ_LPZ lpz;
PJ_XY xy;
PJ_UV uv;
PJ_LP lp;
PJ_COORD proj_coord (double x, double y, double z, double t)
ctypedef enum PJ_DIRECTION:
PJ_FWD # Forward
PJ_IDENT # Do nothing
PJ_INV # Inverse
int proj_angular_input (PJ *P, PJ_DIRECTION dir)
int proj_angular_output (PJ *P, PJ_DIRECTION dir)
int proj_degree_input (PJ *P, PJ_DIRECTION dir)
int proj_degree_output (PJ *P, PJ_DIRECTION dir)
PJ_COORD proj_trans (PJ *P, PJ_DIRECTION direction, PJ_COORD coord)
size_t proj_trans_generic (
PJ *P,
PJ_DIRECTION direction,
double *x, size_t sx, size_t nx,
double *y, size_t sy, size_t ny,
double *z, size_t sz, size_t nz,
double *t, size_t st, size_t nt
)
int proj_trans_bounds(
PJ_CONTEXT* context,
PJ *P,
PJ_DIRECTION direction,
const double xmin,
const double ymin,
const double xmax,
const double ymax,
double* out_xmin,
double* out_ymin,
double* out_xmax,
double* out_ymax,
int densify_pts
)
ctypedef struct PJ_AREA
PJ *proj_create_crs_to_crs_from_pj(
PJ_CONTEXT *ctx,
PJ *source_crs,
PJ *target_crs,
PJ_AREA *area,
const char* const *options,
)
ctypedef enum PJ_COMPARISON_CRITERION:
PJ_COMP_STRICT
PJ_COMP_EQUIVALENT
PJ_COMP_EQUIVALENT_EXCEPT_AXIS_ORDER_GEOGCRS
void proj_destroy(PJ *obj)
int proj_is_equivalent_to_with_ctx(PJ_CONTEXT *ctx,
const PJ *obj, const PJ *other,
PJ_COMPARISON_CRITERION criterion)
const char* proj_get_id_auth_name(const PJ *obj, int index)
const char* proj_get_id_code(const PJ *obj, int index)
int proj_get_area_of_use(PJ_CONTEXT *ctx,
const PJ *obj,
double* out_west_lon_degree,
double* out_south_lat_degree,
double* out_east_lon_degree,
double* out_north_lat_degree,
const char **out_area_name)
PJ_AREA *proj_area_create()
void proj_area_set_bbox(PJ_AREA *area,
double west_lon_degree,
double south_lat_degree,
double east_lon_degree,
double north_lat_degree)
void proj_area_destroy(PJ_AREA* area)
ctypedef enum PJ_WKT_TYPE:
PJ_WKT2_2015
PJ_WKT2_2015_SIMPLIFIED
PJ_WKT2_2019
PJ_WKT2_2019_SIMPLIFIED
PJ_WKT1_GDAL
PJ_WKT1_ESRI
const char* proj_as_wkt(PJ_CONTEXT *ctx,
const PJ *obj,
PJ_WKT_TYPE type,
const char* const *options)
ctypedef enum PJ_PROJ_STRING_TYPE:
PJ_PROJ_5
PJ_PROJ_4
const char* proj_as_proj_string(PJ_CONTEXT *ctx,
const PJ *obj,
PJ_PROJ_STRING_TYPE type,
const char* const *options)
const char* proj_as_projjson(PJ_CONTEXT *ctx,
const PJ *obj,
const char* const *options)
PJ *proj_crs_get_geodetic_crs(PJ_CONTEXT *ctx, const PJ *crs)
ctypedef enum PJ_TYPE:
PJ_TYPE_UNKNOWN
PJ_TYPE_ELLIPSOID
PJ_TYPE_PRIME_MERIDIAN
PJ_TYPE_GEODETIC_REFERENCE_FRAME
PJ_TYPE_DYNAMIC_GEODETIC_REFERENCE_FRAME
PJ_TYPE_VERTICAL_REFERENCE_FRAME
PJ_TYPE_DYNAMIC_VERTICAL_REFERENCE_FRAME
PJ_TYPE_DATUM_ENSEMBLE
PJ_TYPE_CRS
PJ_TYPE_GEODETIC_CRS
PJ_TYPE_GEOCENTRIC_CRS
PJ_TYPE_GEOGRAPHIC_CRS
PJ_TYPE_GEOGRAPHIC_2D_CRS
PJ_TYPE_GEOGRAPHIC_3D_CRS
PJ_TYPE_VERTICAL_CRS
PJ_TYPE_PROJECTED_CRS
PJ_TYPE_COMPOUND_CRS
PJ_TYPE_TEMPORAL_CRS
PJ_TYPE_ENGINEERING_CRS
PJ_TYPE_BOUND_CRS
PJ_TYPE_OTHER_CRS
PJ_TYPE_CONVERSION
PJ_TYPE_TRANSFORMATION
PJ_TYPE_CONCATENATED_OPERATION
PJ_TYPE_OTHER_COORDINATE_OPERATION
PJ_TYPE_TEMPORAL_DATUM
PJ_TYPE_ENGINEERING_DATUM
PJ_TYPE_PARAMETRIC_DATUM
PJ_TYPE_DERIVED_PROJECTED_CRS
PJ_TYPE proj_get_type(const PJ *obj)
const char* proj_get_name(const PJ *obj)
const char* proj_get_remarks(const PJ *obj)
const char* proj_get_scope(const PJ *obj)
int proj_is_crs(const PJ *obj)
int proj_is_derived_crs(PJ_CONTEXT *ctx, const PJ* crs)
PJ *proj_crs_get_datum(PJ_CONTEXT *ctx, const PJ *crs)
PJ *proj_crs_get_horizontal_datum(PJ_CONTEXT *ctx, const PJ *crs)
ctypedef enum PJ_COORDINATE_SYSTEM_TYPE:
PJ_CS_TYPE_UNKNOWN
PJ_CS_TYPE_CARTESIAN
PJ_CS_TYPE_ELLIPSOIDAL
PJ_CS_TYPE_VERTICAL
PJ_CS_TYPE_SPHERICAL
PJ_CS_TYPE_ORDINAL
PJ_CS_TYPE_PARAMETRIC
PJ_CS_TYPE_DATETIMETEMPORAL
PJ_CS_TYPE_TEMPORALCOUNT
PJ_CS_TYPE_TEMPORALMEASURE
PJ *proj_crs_get_coordinate_system(PJ_CONTEXT *ctx, const PJ *crs)
PJ_COORDINATE_SYSTEM_TYPE proj_cs_get_type(PJ_CONTEXT *ctx,
const PJ *cs)
int proj_cs_get_axis_count(PJ_CONTEXT *ctx,
const PJ *cs)
int proj_cs_get_axis_info(PJ_CONTEXT *ctx,
const PJ *cs, int index,
const char **out_name,
const char **out_abbrev,
const char **out_direction,
double *out_unit_conv_factor,
const char **out_unit_name,
const char **out_unit_auth_name,
const char **out_unit_code)
PJ *proj_get_ellipsoid(PJ_CONTEXT *ctx, const PJ *obj)
int proj_ellipsoid_get_parameters(PJ_CONTEXT *ctx,
const PJ *ellipsoid,
double *out_semi_major_metre,
double *out_semi_minor_metre,
int *out_is_semi_minor_computed,
double *out_inv_flattening)
PJ *proj_get_prime_meridian(PJ_CONTEXT *ctx, const PJ *obj)
int proj_prime_meridian_get_parameters(PJ_CONTEXT *ctx,
const PJ *prime_meridian,
double *out_longitude,
double *out_unit_conv_factor,
const char **out_unit_name)
PJ *proj_crs_get_sub_crs(PJ_CONTEXT *ctx, const PJ *crs, int index)
PJ *proj_get_source_crs(PJ_CONTEXT *ctx, const PJ *obj)
PJ *proj_get_target_crs(PJ_CONTEXT *ctx, const PJ *obj)
ctypedef struct PJ_OBJ_LIST
PJ_OBJ_LIST *proj_identify(PJ_CONTEXT *ctx,
const PJ* obj,
const char *auth_name,
const char* const *options,
int **out_confidence)
PJ *proj_list_get(PJ_CONTEXT *ctx,
const PJ_OBJ_LIST *result,
int index)
int proj_list_get_count(const PJ_OBJ_LIST *result)
void proj_list_destroy(PJ_OBJ_LIST *result)
void proj_int_list_destroy(int* list)
void proj_context_use_proj4_init_rules(PJ_CONTEXT *ctx, int enable)
ctypedef enum PJ_GUESSED_WKT_DIALECT:
PJ_GUESSED_WKT2_2018
PJ_GUESSED_WKT2_2015
PJ_GUESSED_WKT1_GDAL
PJ_GUESSED_WKT1_ESRI
PJ_GUESSED_NOT_WKT
PJ_GUESSED_WKT_DIALECT proj_context_guess_wkt_dialect(PJ_CONTEXT *ctx,
const char *wkt)
ctypedef struct PJ_OPERATIONS:
const char *id
PJ *(*proj)(PJ *)
const char * const *descr
const PJ_OPERATIONS *proj_list_operations()
ctypedef struct PJ_ELLPS:
const char *id # ellipse keyword name
const char *major # a= value
const char *ell # elliptical parameter
const char *name # comments
const PJ_ELLPS *proj_list_ellps()
ctypedef struct PJ_PRIME_MERIDIANS:
const char *id
const char *defn
const PJ_PRIME_MERIDIANS *proj_list_prime_meridians()
ctypedef char **PROJ_STRING_LIST
void proj_string_list_destroy(PROJ_STRING_LIST list)
PROJ_STRING_LIST proj_get_authorities_from_database(PJ_CONTEXT *ctx)
PROJ_STRING_LIST proj_get_codes_from_database(PJ_CONTEXT *ctx,
const char *auth_name,
PJ_TYPE type,
int allow_deprecated)
ctypedef struct PROJ_CRS_INFO:
char* auth_name
char* code
char* name
PJ_TYPE type
int deprecated
int bbox_valid
double west_lon_degree
double south_lat_degree
double east_lon_degree
double north_lat_degree
char* area_name
char* projection_method_name
ctypedef struct PROJ_CRS_LIST_PARAMETERS:
const PJ_TYPE* types
size_t typesCount
int crs_area_of_use_contains_bbox
int bbox_valid
double west_lon_degree
double south_lat_degree
double east_lon_degree
double north_lat_degree
int allow_deprecated
PROJ_CRS_LIST_PARAMETERS *proj_get_crs_list_parameters_create()
void proj_get_crs_list_parameters_destroy(PROJ_CRS_LIST_PARAMETERS* params)
PROJ_CRS_INFO **proj_get_crs_info_list_from_database(
PJ_CONTEXT *ctx,
const char *auth_name,
const PROJ_CRS_LIST_PARAMETERS* params,
int *out_result_count)
void proj_crs_info_list_destroy(PROJ_CRS_INFO** list)
PJ *proj_crs_get_coordoperation(PJ_CONTEXT *ctx,
const PJ *crs)
int proj_coordoperation_get_method_info(PJ_CONTEXT *ctx,
const PJ *coordoperation,
const char **out_method_name,
const char **out_method_auth_name,
const char **out_method_code)
int proj_coordoperation_is_instantiable(PJ_CONTEXT *ctx,
const PJ *coordoperation)
int proj_coordoperation_has_ballpark_transformation(PJ_CONTEXT *ctx,
const PJ *coordoperation)
int proj_coordoperation_get_param_count(PJ_CONTEXT *ctx,
const PJ *coordoperation)
int proj_coordoperation_get_param_index(PJ_CONTEXT *ctx,
const PJ *coordoperation,
const char *name)
int proj_coordoperation_get_param(PJ_CONTEXT *ctx,
const PJ *coordoperation,
int index,
const char **out_name,
const char **out_auth_name,
const char **out_code,
double *out_value,
const char **out_value_string,
double *out_unit_conv_factor,
const char **out_unit_name,
const char **out_unit_auth_name,
const char **out_unit_code,
const char **out_unit_category)
int proj_coordoperation_get_grid_used_count(PJ_CONTEXT *ctx,
const PJ *coordoperation)
int proj_coordoperation_get_grid_used(PJ_CONTEXT *ctx,
const PJ *coordoperation,
int index,
const char **out_short_name,
const char **out_full_name,
const char **out_package_name,
const char **out_url,
int *out_direct_download,
int *out_open_license,
int *out_available)
double proj_coordoperation_get_accuracy(PJ_CONTEXT *ctx,
const PJ *obj)
int proj_coordoperation_get_towgs84_values(PJ_CONTEXT *ctx,
const PJ *coordoperation,
double *out_values,
int value_count,
int emit_error_if_incompatible)
int proj_concatoperation_get_step_count(PJ_CONTEXT *ctx,
const PJ *concatoperation)
PJ *proj_concatoperation_get_step(PJ_CONTEXT *ctx,
const PJ *concatoperation,
int i_step)
ctypedef enum PJ_CATEGORY:
PJ_CATEGORY_ELLIPSOID
PJ_CATEGORY_PRIME_MERIDIAN
PJ_CATEGORY_DATUM
PJ_CATEGORY_CRS
PJ_CATEGORY_COORDINATE_OPERATION
PJ_CATEGORY_DATUM_ENSEMBLE
PJ *proj_create_from_database(PJ_CONTEXT *ctx,
const char *auth_name,
const char *code,
PJ_CATEGORY category,
int usePROJAlternativeGridNames,
const char* const *options)
PJ_OBJ_LIST *proj_create_from_name(PJ_CONTEXT *ctx,
const char *auth_name,
const char *searchedName,
const PJ_TYPE* types,
size_t typesCount,
int approximateMatch,
size_t limitResultCount,
const char* const *options)
ctypedef struct PJ_OPERATION_FACTORY_CONTEXT
PJ_OPERATION_FACTORY_CONTEXT *proj_create_operation_factory_context(
PJ_CONTEXT *ctx,
const char *authority
)
void proj_operation_factory_context_destroy(
PJ_OPERATION_FACTORY_CONTEXT *ctx
)
PJ_OBJ_LIST *proj_create_operations(
PJ_CONTEXT *ctx,
const PJ *source_crs,
const PJ *target_crs,
const PJ_OPERATION_FACTORY_CONTEXT *operationContext
)
void proj_operation_factory_context_set_grid_availability_use(
PJ_CONTEXT *ctx,
PJ_OPERATION_FACTORY_CONTEXT *factory_ctx,
PROJ_GRID_AVAILABILITY_USE use
)
void proj_operation_factory_context_set_spatial_criterion(
PJ_CONTEXT *ctx,
PJ_OPERATION_FACTORY_CONTEXT *factory_ctx,
PROJ_SPATIAL_CRITERION criterion
)
void proj_operation_factory_context_set_area_of_interest(
PJ_CONTEXT *ctx,
PJ_OPERATION_FACTORY_CONTEXT *factory_ctx,
double west_lon_degree,
double south_lat_degree,
double east_lon_degree,
double north_lat_degree
)
void proj_operation_factory_context_set_allow_ballpark_transformations(
PJ_CONTEXT *ctx,
PJ_OPERATION_FACTORY_CONTEXT *factory_ctx,
int allow
)
void proj_operation_factory_context_set_discard_superseded(
PJ_CONTEXT *ctx,
PJ_OPERATION_FACTORY_CONTEXT *factory_ctx,
int discard
)
void proj_operation_factory_context_set_desired_accuracy(
PJ_CONTEXT *ctx,
PJ_OPERATION_FACTORY_CONTEXT *factory_ctx,
double accuracy
)
ctypedef enum PROJ_SPATIAL_CRITERION:
PROJ_SPATIAL_CRITERION_STRICT_CONTAINMENT
PROJ_SPATIAL_CRITERION_PARTIAL_INTERSECTION
ctypedef enum PROJ_GRID_AVAILABILITY_USE:
PROJ_GRID_AVAILABILITY_USED_FOR_SORTING
PROJ_GRID_AVAILABILITY_DISCARD_OPERATION_IF_MISSING_GRID
PROJ_GRID_AVAILABILITY_IGNORED
PROJ_GRID_AVAILABILITY_KNOWN_AVAILABLE
ctypedef struct PJ_FACTORS:
double meridional_scale
double parallel_scale
double areal_scale
double angular_distortion
double meridian_parallel_angle
double meridian_convergence
double tissot_semimajor
double tissot_semiminor
double dx_dlam
double dx_dphi
double dy_dlam
double dy_dphi
PJ_FACTORS proj_factors(PJ *P, PJ_COORD lp)
# neworking related
const char *proj_context_get_user_writable_directory(PJ_CONTEXT *ctx, int create)
int proj_context_set_enable_network(PJ_CONTEXT* ctx, int enabled)
int proj_context_is_network_enabled(PJ_CONTEXT* ctx)
# units
ctypedef struct PROJ_UNIT_INFO:
# Authority name.
char* auth_name
# Object code.
char* code
# Object name. For example "metre", "US survey foot", etc. */
char* name
# Category of the unit: one of "linear", "linear_per_time", "angular",
# "angular_per_time", "scale", "scale_per_time" or "time" */
char* category
# Conversion factor to apply to transform from that unit to the
# corresponding SI unit (metre for "linear", radian for "angular", etc.).
# It might be 0 in some cases to indicate no known conversion factor.
double conv_factor
# PROJ short name, like "m", "ft", "us-ft", etc... Might be NULL */
char* proj_short_name
# Whether the object is deprecated
int deprecated
PROJ_UNIT_INFO **proj_get_units_from_database(
PJ_CONTEXT *ctx,
const char *auth_name,
const char *category,
int allow_deprecated,
int *out_result_count,
)
void proj_unit_list_destroy(PROJ_UNIT_INFO** list)
const char *proj_context_get_url_endpoint(PJ_CONTEXT* ctx)
pyproj-3.6.1/pyproj/proj.py 0000664 0000000 0000000 00000025766 14502715416 0015740 0 ustar 00root root 0000000 0000000 """
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
:ref:`projections` 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).
"""
import re
import warnings
from typing import Any, Optional
from pyproj._compat import cstrencode
from pyproj._transformer import Factors
from pyproj.crs import CRS
from pyproj.enums import TransformDirection
from pyproj.list import get_proj_operations_map
from pyproj.transformer import Transformer, TransformerFromPipeline
from pyproj.utils import _convertback, _copytobuffer
pj_list = get_proj_operations_map()
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: Optional[Any] = None, preserve_units: bool = True, **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
:ref:`projections` for examples of
key/value pairs defining different map projections.
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.
**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__(TransformerFromPipeline(cstrencode(self.srs)))
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.
Accepted numeric scalar or array:
- :class:`int`
- :class:`float`
- :class:`numpy.floating`
- :class:`numpy.integer`
- :class:`list`
- :class:`tuple`
- :class:`array.array`
- :class:`numpy.ndarray`
- :class:`xarray.DataArray`
- :class:`pandas.Series`
Parameters
----------
longitude: scalar or array
Input longitude coordinate(s).
latitude: scalar or array
Input latitude coordinate(s).
inverse: bool, default=False
If inverse is True the inverse transformation from x/y to
lon/lat is performed.
radians: bool, default=False
If True, will expect input data to be in radians and will return radians
if the projection is geographic. Otherwise, it uses degrees.
This does not work with pyproj 2 and is ignored. It will be enabled again
in pyproj 3.
errcheck: bool, default=False
If True, an exception is raised if the errors are found in the process.
If False, ``inf`` is returned for errors.
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.
Accepted numeric scalar or array:
- :class:`int`
- :class:`float`
- :class:`numpy.floating`
- :class:`numpy.integer`
- :class:`list`
- :class:`tuple`
- :class:`array.array`
- :class:`numpy.ndarray`
- :class:`xarray.DataArray`
- :class:`pandas.Series`
Parameters
----------
longitude: scalar or array
Input longitude coordinate(s).
latitude: scalar or array
Input latitude coordinate(s).
radians: bool, default=False
If True, will expect input data to be in radians and will return radians
if the projection is geographic. Otherwise, it uses degrees.
errcheck: bool, default=False
If True, an exception is raised if the errors are found in the process.
If False, ``inf`` is returned on error.
Returns
-------
Factors
"""
# process inputs, making copies that support buffer API.
inx, x_data_type = _copytobuffer(longitude)
iny = _copytobuffer(latitude)[0]
# 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(x_data_type, factors.meridional_scale),
parallel_scale=_convertback(x_data_type, factors.parallel_scale),
areal_scale=_convertback(x_data_type, factors.areal_scale),
angular_distortion=_convertback(x_data_type, factors.angular_distortion),
meridian_parallel_angle=_convertback(
x_data_type, factors.meridian_parallel_angle
),
meridian_convergence=_convertback(
x_data_type, factors.meridian_convergence
),
tissot_semimajor=_convertback(x_data_type, factors.tissot_semimajor),
tissot_semiminor=_convertback(x_data_type, factors.tissot_semiminor),
dx_dlam=_convertback(x_data_type, factors.dx_dlam),
dx_dphi=_convertback(x_data_type, factors.dx_dphi),
dy_dlam=_convertback(x_data_type, factors.dy_dlam),
dy_dphi=_convertback(x_data_type, 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 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,)
pyproj-3.6.1/pyproj/py.typed 0000664 0000000 0000000 00000000000 14502715416 0016061 0 ustar 00root root 0000000 0000000 pyproj-3.6.1/pyproj/sync.py 0000664 0000000 0000000 00000020752 14502715416 0015730 0 ustar 00root root 0000000 0000000 """
Based on the logic in the PROJ projsync CLI program
https://github.com/OSGeo/PROJ/blob/9ff543c4ffd86152bc58d0a0164b2ce9ebbb8bec/src/apps/projsync.cpp
"""
import hashlib
import json
import os
from datetime import datetime
from functools import partial
from pathlib import Path
from typing import Any, Optional
from urllib.request import urlretrieve
from pyproj._sync import get_proj_endpoint
from pyproj.aoi import BBox
from pyproj.datadir import get_data_dir, get_user_data_dir
def _bbox_from_coords(coords: list) -> Optional[BBox]:
"""
Get the bounding box from coordinates
"""
try:
xxx, yyy = zip(*coords)
return BBox(west=min(xxx), south=min(yyy), east=max(xxx), north=max(yyy))
except ValueError:
pass
coord_bbox = None
for coord_set in coords:
bbox = _bbox_from_coords(coord_set)
if coord_bbox is None:
coord_bbox = bbox
else:
coord_bbox.west = min(coord_bbox.west, bbox.west)
coord_bbox.south = min(coord_bbox.south, bbox.south)
coord_bbox.north = max(coord_bbox.north, bbox.north)
coord_bbox.east = max(coord_bbox.east, bbox.east)
return coord_bbox
def _bbox_from_geom(geom: dict[str, Any]) -> Optional[BBox]:
"""
Get the bounding box from geojson geometry
"""
if "coordinates" not in geom or "type" not in geom:
return None
coordinates = geom["coordinates"]
if geom["type"] != "MultiPolygon":
return _bbox_from_coords(coordinates)
found_minus_180 = False
found_plus_180 = False
bboxes = []
for coordinate_set in coordinates:
bbox = _bbox_from_coords(coordinate_set)
if bbox is None:
continue
if bbox.west == -180:
found_minus_180 = True
elif bbox.east == 180:
found_plus_180 = True
bboxes.append(bbox)
grid_bbox = None
for bbox in bboxes:
if found_minus_180 and found_plus_180 and bbox.west == -180:
bbox.west = 180
bbox.east += 360
if grid_bbox is None:
grid_bbox = bbox
else:
grid_bbox.west = min(grid_bbox.west, bbox.west)
grid_bbox.south = min(grid_bbox.south, bbox.south)
grid_bbox.north = max(grid_bbox.north, bbox.north)
grid_bbox.east = max(grid_bbox.east, bbox.east)
return grid_bbox
def _filter_bbox(
feature: dict[str, Any], bbox: BBox, spatial_test: str, include_world_coverage: bool
) -> bool:
"""
Filter by the bounding box. Designed to use with 'filter'
"""
geom = feature.get("geometry")
if geom is not None:
geom_bbox = _bbox_from_geom(geom)
if geom_bbox is None:
return False
if (
geom_bbox.east - geom_bbox.west > 359
and geom_bbox.north - geom_bbox.south > 179
):
if not include_world_coverage:
return False
geom_bbox.west = -float("inf")
geom_bbox.east = float("inf")
elif geom_bbox.east > 180 and bbox.west < -180:
geom_bbox.west -= 360
geom_bbox.east -= 360
return getattr(bbox, spatial_test)(geom_bbox)
return False
def _filter_properties(
feature: dict[str, Any],
source_id: Optional[str] = None,
area_of_use: Optional[str] = None,
filename: Optional[str] = None,
) -> bool:
"""
Filter by the properties. Designed to use with 'filter'
"""
properties = feature.get("properties")
if not properties:
return False
p_filename = properties.get("name")
p_source_id = properties.get("source_id")
if not p_filename or not p_source_id:
return False
source_id__matched = source_id is None or source_id in p_source_id
area_of_use__matched = area_of_use is None or area_of_use in properties.get(
"area_of_use", ""
)
filename__matched = filename is None or filename in p_filename
if source_id__matched and area_of_use__matched and filename__matched:
return True
return False
def _is_download_needed(grid_name: str) -> bool:
"""
Run through all of the PROJ directories to see if the
file already exists.
"""
if Path(get_user_data_dir(), grid_name).exists():
return False
for data_dir in get_data_dir().split(os.pathsep):
if Path(data_dir, grid_name).exists():
return False
return True
def _filter_download_needed(feature: dict[str, Any]) -> bool:
"""
Filter grids so only those that need to be downloaded are included.
"""
properties = feature.get("properties")
if not properties:
return False
filename = properties.get("name")
if not filename:
return False
return _is_download_needed(filename)
def _sha256sum(input_file):
"""
Return sha256 checksum of file given by path.
"""
hasher = hashlib.sha256()
with open(input_file, "rb") as file:
for chunk in iter(lambda: file.read(65536), b""):
hasher.update(chunk)
return hasher.hexdigest()
def _download_resource_file(
file_url, short_name, directory, verbose=False, sha256=None
):
"""
Download resource file from PROJ url
"""
if verbose:
print(f"Downloading: {file_url}")
tmp_path = Path(directory, f"{short_name}.part")
try:
urlretrieve(file_url, tmp_path)
if sha256 is not None and sha256 != _sha256sum(tmp_path):
raise RuntimeError(f"SHA256 mismatch: {short_name}")
tmp_path.replace(Path(directory, short_name))
finally:
try:
os.remove(tmp_path)
except FileNotFoundError:
pass
def _load_grid_geojson(target_directory=None) -> dict[str, Any]:
"""
Returns
-------
dict[str, Any]:
The PROJ grid data list.
"""
if target_directory is None:
target_directory = get_user_data_dir(True)
local_path = Path(target_directory, "files.geojson")
if not local_path.exists() or (
(datetime.utcnow() - datetime.fromtimestamp(local_path.stat().st_mtime)).days
> 0
):
_download_resource_file(
file_url=f"{get_proj_endpoint()}/files.geojson",
short_name="files.geojson",
directory=target_directory,
)
return json.loads(local_path.read_text(encoding="utf-8"))
def get_transform_grid_list(
source_id: Optional[str] = None,
area_of_use: Optional[str] = None,
filename: Optional[str] = None,
bbox: Optional[BBox] = None,
spatial_test: str = "intersects",
include_world_coverage: bool = True,
include_already_downloaded: bool = False,
target_directory: Optional[str] = None,
) -> tuple:
"""
Get a list of transform grids that can be downloaded.
Parameters
----------
source_id: str, optional
area_of_use: str, optional
filename: str, optional
bbox: BBox, optional
spatial_test: str, default="intersects"
Can be "contains" or "intersects".
include_world_coverage: bool, default=True
If True, it will include grids with a global extent.
include_already_downloaded: bool, default=False
If True, it will list grids regardless of if they are downloaded.
target_directory: Union[str, Path, None], optional
The directory to download the geojson file to.
Default is the user writable directory.
Returns
-------
list[dict[str, Any]]:
A list of geojson data of containing information about features
that can be downloaded.
"""
features = _load_grid_geojson(target_directory=target_directory)["features"]
if bbox is not None:
if bbox.west > 180 and bbox.east > bbox.west:
bbox.west -= 360
bbox.east -= 360
elif bbox.west < -180 and bbox.east > bbox.west:
bbox.west += 360
bbox.east += 360
elif abs(bbox.west) < 180 and abs(bbox.east) < 180 and bbox.east < bbox.west:
bbox.east += 360
features = filter(
partial(
_filter_bbox,
bbox=bbox,
spatial_test=spatial_test,
include_world_coverage=include_world_coverage,
),
features,
)
# filter by properties
features = filter(
partial(
_filter_properties,
source_id=source_id,
area_of_use=area_of_use,
filename=filename,
),
features,
)
if include_already_downloaded:
return tuple(features)
return tuple(filter(_filter_download_needed, features))
pyproj-3.6.1/pyproj/transformer.py 0000664 0000000 0000000 00000127667 14502715416 0017333 0 ustar 00root root 0000000 0000000 """
The transformer module is for performing cartographic transformations.
"""
__all__ = [
"transform",
"itransform",
"Transformer",
"TransformerGroup",
"AreaOfInterest",
]
import threading
import warnings
from abc import ABC, abstractmethod
from array import array
from collections.abc import Iterable, Iterator
from dataclasses import dataclass
from itertools import chain, islice
from pathlib import Path
from typing import Any, Optional, Union, overload
from pyproj import CRS
from pyproj._compat import cstrencode
from pyproj._crs import AreaOfUse, CoordinateOperation
from pyproj._datadir import _clear_proj_error
from pyproj._transformer import ( # noqa: F401 pylint: disable=unused-import
AreaOfInterest,
_Transformer,
_TransformerGroup,
proj_version_str,
)
from pyproj.datadir import get_user_data_dir
from pyproj.enums import ProjVersion, TransformDirection, WktVersion
from pyproj.exceptions import ProjError
from pyproj.sync import _download_resource_file
from pyproj.utils import _convertback, _copytobuffer
class TransformerMaker(ABC):
"""
.. versionadded:: 3.1.0
Base class for generating new instances
of the Cython _Transformer class for
thread safety in the Transformer class.
"""
@abstractmethod
def __call__(self) -> _Transformer:
"""
Returns
-------
_Transformer
"""
raise NotImplementedError
@dataclass(frozen=True)
class TransformerUnsafe(TransformerMaker):
"""
.. versionadded:: 3.1.0
Returns the original Cython _Transformer
and is not thread-safe.
"""
transformer: _Transformer
def __call__(self) -> _Transformer:
"""
Returns
-------
_Transformer
"""
return self.transformer
@dataclass(frozen=True)
class TransformerFromCRS( # pylint: disable=too-many-instance-attributes
TransformerMaker
):
"""
.. versionadded:: 3.1.0
.. versionadded:: 3.4.0 force_over
Generates a Cython _Transformer class from input CRS data.
"""
crs_from: bytes
crs_to: bytes
always_xy: bool
area_of_interest: Optional[AreaOfInterest]
authority: Optional[str]
accuracy: Optional[str]
allow_ballpark: Optional[bool]
force_over: bool = False
only_best: Optional[bool] = None
def __call__(self) -> _Transformer:
"""
Returns
-------
_Transformer
"""
return _Transformer.from_crs(
self.crs_from,
self.crs_to,
always_xy=self.always_xy,
area_of_interest=self.area_of_interest,
authority=self.authority,
accuracy=self.accuracy,
allow_ballpark=self.allow_ballpark,
force_over=self.force_over,
only_best=self.only_best,
)
@dataclass(frozen=True)
class TransformerFromPipeline(TransformerMaker):
"""
.. versionadded:: 3.1.0
Generates a Cython _Transformer class from input pipeline data.
"""
proj_pipeline: bytes
def __call__(self) -> _Transformer:
"""
Returns
-------
_Transformer
"""
return _Transformer.from_pipeline(self.proj_pipeline)
class TransformerGroup(_TransformerGroup):
"""
The TransformerGroup is a set of possible transformers from one CRS to another.
.. versionadded:: 2.3.0
.. warning:: CoordinateOperation and Transformer objects
returned are not thread-safe.
From PROJ docs::
The operations are sorted with the most relevant ones first: by
descending area (intersection of the transformation area with the
area of interest, or intersection of the transformation with the
area of use of the CRS), and by increasing accuracy. Operations
with unknown accuracy are sorted last, whatever their area.
"""
def __init__(
self,
crs_from: Any,
crs_to: Any,
always_xy: bool = False,
area_of_interest: Optional[AreaOfInterest] = None,
authority: Optional[str] = None,
accuracy: Optional[float] = None,
allow_ballpark: bool = True,
allow_superseded: bool = False,
) -> None:
"""Get all possible transformations from a :obj:`pyproj.crs.CRS`
or input used to create one.
.. versionadded:: 3.4.0 authority, accuracy, allow_ballpark
.. versionadded:: 3.6.0 allow_superseded
Parameters
----------
crs_from: pyproj.crs.CRS or input used to create one
Projection of input data.
crs_to: pyproj.crs.CRS or input used to create one
Projection of output data.
always_xy: bool, default=False
If true, the transform method will accept as input and return as output
coordinates using the traditional GIS order, that is longitude, latitude
for geographic CRS and easting, northing for most projected CRS.
area_of_interest: :class:`.AreaOfInterest`, optional
The area of interest to help order the transformations based on the
best operation for the area.
authority: str, optional
When not specified, coordinate operations from any authority will be
searched, with the restrictions set in the
authority_to_authority_preference database table related to the
authority of the source/target CRS themselves. If authority is set
to “any”, then coordinate operations from any authority will be
searched. If authority is a non-empty string different from "any",
then coordinate operations will be searched only in that authority
namespace (e.g. EPSG).
accuracy: float, optional
The minimum desired accuracy (in metres) of the candidate
coordinate operations.
allow_ballpark: bool, default=True
Set to False to disallow the use of Ballpark transformation
in the candidate coordinate operations. Default is to allow.
allow_superseded: bool, default=False
Set to True to allow the use of superseded (but not deprecated)
transformations in the candidate coordinate operations. Default is
to disallow.
"""
super().__init__(
CRS.from_user_input(crs_from)._crs,
CRS.from_user_input(crs_to)._crs,
always_xy=always_xy,
area_of_interest=area_of_interest,
authority=authority,
accuracy=-1 if accuracy is None else accuracy,
allow_ballpark=allow_ballpark,
allow_superseded=allow_superseded,
)
for iii, transformer in enumerate(self._transformers):
# pylint: disable=unsupported-assignment-operation
self._transformers[iii] = Transformer(TransformerUnsafe(transformer))
@property
def transformers(self) -> list["Transformer"]:
"""
list[:obj:`Transformer`]:
List of available :obj:`Transformer`
associated with the transformation.
"""
return self._transformers
@property
def unavailable_operations(self) -> list[CoordinateOperation]:
"""
list[:obj:`pyproj.crs.CoordinateOperation`]:
List of :obj:`pyproj.crs.CoordinateOperation` that are not
available due to missing grids.
"""
return self._unavailable_operations
@property
def best_available(self) -> bool:
"""
bool: If True, the best possible transformer is available.
"""
return self._best_available
def download_grids(
self,
directory: Optional[Union[str, Path]] = None,
open_license: bool = True,
verbose: bool = False,
) -> None:
"""
.. versionadded:: 3.0.0
Download missing grids that can be downloaded automatically.
.. warning:: There are cases where the URL to download the grid is missing.
In those cases, you can enable enable
:ref:`debugging-internal-proj` and perform a
transformation. The logs will show the grids PROJ searches for.
Parameters
----------
directory: str or Path, optional
The directory to download the grids to.
Defaults to :func:`pyproj.datadir.get_user_data_dir`
open_license: bool, default=True
If True, will only download grids with an open license.
verbose: bool, default=False
If True, will print information about grids downloaded.
"""
if directory is None:
directory = get_user_data_dir(True)
# pylint: disable=not-an-iterable
for unavailable_operation in self.unavailable_operations:
for grid in unavailable_operation.grids:
if (
not grid.available
and grid.url.endswith(grid.short_name)
and grid.direct_download
and (grid.open_license or not open_license)
):
_download_resource_file(
file_url=grid.url,
short_name=grid.short_name,
directory=directory,
verbose=verbose,
)
elif not grid.available and verbose:
warnings.warn(f"Skipped: {grid}")
def __repr__(self) -> str:
return (
f"\n"
f"- transformers: {len(self.transformers)}\n"
f"- unavailable_operations: {len(self.unavailable_operations)}"
)
class TransformerLocal(threading.local):
"""
Threading local instance for cython _Transformer class.
For more details, see:
https://github.com/pyproj4/pyproj/issues/782
"""
def __init__(self):
self.transformer = None # Initialises in each thread
super().__init__()
class Transformer:
"""
The Transformer class is for facilitating re-using
transforms without needing to re-create them. The goal
is to make repeated transforms faster.
Additionally, it provides multiple methods for initialization.
.. versionadded:: 2.1.0
"""
def __init__(
self,
transformer_maker: Union[TransformerMaker, None] = None,
) -> None:
if not isinstance(transformer_maker, TransformerMaker):
_clear_proj_error()
raise ProjError(
"Transformer must be initialized using: "
"'from_crs' or 'from_pipeline'."
)
self._local = TransformerLocal()
self._local.transformer = transformer_maker()
self._transformer_maker = transformer_maker
def __getstate__(self) -> dict[str, Any]:
return {"_transformer_maker": self._transformer_maker}
def __setstate__(self, state: dict[str, Any]):
self.__dict__.update(state)
self._local = TransformerLocal()
self._local.transformer = self._transformer_maker()
@property
def _transformer(self):
"""
The Cython _Transformer object for this thread.
Returns
-------
_Transformer
"""
if self._local.transformer is None:
self._local.transformer = self._transformer_maker()
return self._local.transformer
@property
def name(self) -> str:
"""
str: Name of the projection.
"""
return self._transformer.id
@property
def description(self) -> str:
"""
str: Description of the projection.
"""
return self._transformer.description
@property
def definition(self) -> str:
"""
str: Definition of the projection.
"""
return self._transformer.definition
@property
def has_inverse(self) -> bool:
"""
bool: True if an inverse mapping exists.
"""
return self._transformer.has_inverse
@property
def accuracy(self) -> float:
"""
float: Expected accuracy of the transformation. -1 if unknown.
"""
return self._transformer.accuracy
@property
def area_of_use(self) -> AreaOfUse:
"""
.. versionadded:: 2.3.0
Returns
-------
AreaOfUse:
The area of use object with associated attributes.
"""
return self._transformer.area_of_use
@property
def remarks(self) -> str:
"""
.. versionadded:: 2.4.0
Returns
-------
str:
Remarks about object.
"""
return self._transformer.remarks
@property
def scope(self) -> str:
"""
.. versionadded:: 2.4.0
Returns
-------
str:
Scope of object.
"""
return self._transformer.scope
@property
def operations(self) -> Optional[tuple[CoordinateOperation]]:
"""
.. versionadded:: 2.4.0
Returns
-------
tuple[CoordinateOperation]:
The operations in a concatenated operation.
"""
return self._transformer.operations
def get_last_used_operation(self) -> "Transformer":
"""
.. versionadded:: 3.4.0
.. note:: Requires PROJ 9.1+
See: :c:func:`proj_trans_get_last_used_operation`
Returns
-------
Transformer:
The operation used in the transform call.
"""
return Transformer(
TransformerUnsafe(self._transformer.get_last_used_operation())
)
@property
def is_network_enabled(self) -> bool:
"""
.. versionadded:: 3.0.0
Returns
-------
bool:
If the network is enabled.
"""
return self._transformer.is_network_enabled
@property
def source_crs(self) -> Optional[CRS]:
"""
.. versionadded:: 3.3.0
Returns
-------
Optional[CRS]:
The source CRS of a CoordinateOperation.
"""
return (
None
if self._transformer.source_crs is None
else CRS(self._transformer.source_crs)
)
@property
def target_crs(self) -> Optional[CRS]:
"""
.. versionadded:: 3.3.0
Returns
-------
Optional[CRS]:
The target CRS of a CoordinateOperation.
"""
return (
None
if self._transformer.target_crs is None
else CRS(self._transformer.target_crs)
)
@staticmethod
def from_proj(
proj_from: Any,
proj_to: Any,
always_xy: bool = False,
area_of_interest: Optional[AreaOfInterest] = None,
) -> "Transformer":
"""Make a Transformer from a :obj:`pyproj.Proj` or input used to create one.
.. deprecated:: 3.4.1 :meth:`~Transformer.from_crs` is preferred.
.. versionadded:: 2.2.0 always_xy
.. versionadded:: 2.3.0 area_of_interest
Parameters
----------
proj_from: :obj:`pyproj.Proj` or input used to create one
Projection of input data.
proj_to: :obj:`pyproj.Proj` or input used to create one
Projection of output data.
always_xy: bool, default=False
If true, the transform method will accept as input and return as output
coordinates using the traditional GIS order, that is longitude, latitude
for geographic CRS and easting, northing for most projected CRS.
area_of_interest: :class:`.AreaOfInterest`, optional
The area of interest to help select the transformation.
Returns
-------
Transformer
"""
# pylint: disable=import-outside-toplevel
from pyproj import Proj
if not isinstance(proj_from, Proj):
proj_from = Proj(proj_from)
if not isinstance(proj_to, Proj):
proj_to = Proj(proj_to)
return Transformer.from_crs(
proj_from.crs,
proj_to.crs,
always_xy=always_xy,
area_of_interest=area_of_interest,
)
@staticmethod
def from_crs(
crs_from: Any,
crs_to: Any,
always_xy: bool = False,
area_of_interest: Optional[AreaOfInterest] = None,
authority: Optional[str] = None,
accuracy: Optional[float] = None,
allow_ballpark: Optional[bool] = None,
force_over: bool = False,
only_best: Optional[bool] = None,
) -> "Transformer":
"""Make a Transformer from a :obj:`pyproj.crs.CRS` or input used to create one.
See:
- :c:func:`proj_create_crs_to_crs`
- :c:func:`proj_create_crs_to_crs_from_pj`
.. versionadded:: 2.2.0 always_xy
.. versionadded:: 2.3.0 area_of_interest
.. versionadded:: 3.1.0 authority, accuracy, allow_ballpark
.. versionadded:: 3.4.0 force_over
.. versionadded:: 3.5.0 only_best
Parameters
----------
crs_from: pyproj.crs.CRS or input used to create one
Projection of input data.
crs_to: pyproj.crs.CRS or input used to create one
Projection of output data.
always_xy: bool, default=False
If true, the transform method will accept as input and return as output
coordinates using the traditional GIS order, that is longitude, latitude
for geographic CRS and easting, northing for most projected CRS.
area_of_interest: :class:`.AreaOfInterest`, optional
The area of interest to help select the transformation.
authority: str, optional
When not specified, coordinate operations from any authority will be
searched, with the restrictions set in the
authority_to_authority_preference database table related to the
authority of the source/target CRS themselves. If authority is set
to “any”, then coordinate operations from any authority will be
searched. If authority is a non-empty string different from "any",
then coordinate operations will be searched only in that authority
namespace (e.g. EPSG).
accuracy: float, optional
The minimum desired accuracy (in metres) of the candidate
coordinate operations.
allow_ballpark: bool, optional
Set to False to disallow the use of Ballpark transformation
in the candidate coordinate operations. Default is to allow.
force_over: bool, default=False
If True, it will to force the +over flag on the transformation.
Requires PROJ 9+.
only_best: bool, optional
Can be set to True to cause PROJ to error out if the best
transformation known to PROJ and usable by PROJ if all grids known and
usable by PROJ were accessible, cannot be used. Best transformation should
be understood as the transformation returned by
:c:func:`proj_get_suggested_operation` if all known grids were
accessible (either locally or through network).
Note that the default value for this option can be also set with the
:envvar:`PROJ_ONLY_BEST_DEFAULT` environment variable, or with the
``only_best_default`` setting of :ref:`proj-ini`.
The only_best kwarg overrides the default value if set.
Requires PROJ 9.2+.
Returns
-------
Transformer
"""
return Transformer(
TransformerFromCRS(
cstrencode(CRS.from_user_input(crs_from).srs),
cstrencode(CRS.from_user_input(crs_to).srs),
always_xy=always_xy,
area_of_interest=area_of_interest,
authority=authority,
accuracy=accuracy if accuracy is None else str(accuracy),
allow_ballpark=allow_ballpark,
force_over=force_over,
only_best=only_best,
)
)
@staticmethod
def from_pipeline(proj_pipeline: str) -> "Transformer":
"""Make a Transformer from a PROJ pipeline string.
:ref:`pipeline`
See:
- :c:func:`proj_create`
- :c:func:`proj_create_from_database`
.. versionadded:: 3.1.0 AUTH:CODE string support (e.g. EPSG:1671)
Allowed input:
- a PROJ string
- a WKT string
- a PROJJSON string
- an object code (e.g. "EPSG:1671"
"urn:ogc:def:coordinateOperation:EPSG::1671")
- an object name. e.g "ITRF2014 to ETRF2014 (1)".
In that case as uniqueness is not guaranteed,
heuristics are applied to determine the appropriate best match.
- a OGC URN combining references for concatenated operations
(e.g. "urn:ogc:def:coordinateOperation,coordinateOperation:EPSG::3895,
coordinateOperation:EPSG::1618")
Parameters
----------
proj_pipeline: str
Projection pipeline string.
Returns
-------
Transformer
"""
return Transformer(TransformerFromPipeline(cstrencode(proj_pipeline)))
@overload
def transform( # pylint: disable=invalid-name
self,
xx: Any,
yy: Any,
radians: bool = False,
errcheck: bool = False,
direction: Union[TransformDirection, str] = TransformDirection.FORWARD,
inplace: bool = False,
) -> tuple[Any, Any]:
...
@overload
def transform( # pylint: disable=invalid-name
self,
xx: Any,
yy: Any,
zz: Any,
radians: bool = False,
errcheck: bool = False,
direction: Union[TransformDirection, str] = TransformDirection.FORWARD,
inplace: bool = False,
) -> tuple[Any, Any, Any]:
...
@overload
def transform( # pylint: disable=invalid-name
self,
xx: Any,
yy: Any,
zz: Any,
tt: Any,
radians: bool = False,
errcheck: bool = False,
direction: Union[TransformDirection, str] = TransformDirection.FORWARD,
inplace: bool = False,
) -> tuple[Any, Any, Any, Any]:
...
def transform( # pylint: disable=invalid-name
self,
xx,
yy,
zz=None,
tt=None,
radians=False,
errcheck=False,
direction=TransformDirection.FORWARD,
inplace=False,
):
"""
Transform points between two coordinate systems.
See: :c:func:`proj_trans_generic`
.. versionadded:: 2.1.1 errcheck
.. versionadded:: 2.2.0 direction
.. versionadded:: 3.2.0 inplace
Accepted numeric scalar or array:
- :class:`int`
- :class:`float`
- :class:`numpy.floating`
- :class:`numpy.integer`
- :class:`list`
- :class:`tuple`
- :class:`array.array`
- :class:`numpy.ndarray`
- :class:`xarray.DataArray`
- :class:`pandas.Series`
Parameters
----------
xx: scalar or array
Input x coordinate(s).
yy: scalar or array
Input y coordinate(s).
zz: scalar or array, optional
Input z coordinate(s).
tt: scalar or array, optional
Input time coordinate(s).
radians: bool, default=False
If True, will expect input data to be in radians and will return radians
if the projection is geographic. Otherwise, it uses degrees.
Ignored for pipeline transformations with pyproj 2,
but will work in pyproj 3.
errcheck: bool, default=False
If True, an exception is raised if the errors are found in the process.
If False, ``inf`` is returned for errors.
direction: pyproj.enums.TransformDirection, optional
The direction of the transform.
Default is :attr:`pyproj.enums.TransformDirection.FORWARD`.
inplace: bool, default=False
If True, will attempt to write the results to the input array
instead of returning a new array. This will fail if the input
is not an array in C order with the double data type.
Example
--------
>>> from pyproj import Transformer
>>> transformer = Transformer.from_crs("EPSG:4326", "EPSG:3857")
>>> x3, y3 = transformer.transform(33, 98)
>>> f"{x3:.3f} {y3:.3f}"
'10909310.098 3895303.963'
>>> pipeline_str = (
... "+proj=pipeline +step +proj=longlat +ellps=WGS84 "
... "+step +proj=unitconvert +xy_in=rad +xy_out=deg"
... )
>>> pipe_trans = Transformer.from_pipeline(pipeline_str)
>>> xt, yt = pipe_trans.transform(2.1, 0.001)
>>> f"{xt:.3f} {yt:.3f}"
'2.100 0.001'
>>> transproj = Transformer.from_crs(
... {"proj":'geocent', "ellps":'WGS84', "datum":'WGS84'},
... "EPSG:4326",
... always_xy=True,
... )
>>> xpj, ypj, zpj = transproj.transform(
... -2704026.010,
... -4253051.810,
... 3895878.820,
... radians=True,
... )
>>> f"{xpj:.3f} {ypj:.3f} {zpj:.3f}"
'-2.137 0.661 -20.531'
>>> transprojr = Transformer.from_crs(
... "EPSG:4326",
... {"proj":'geocent', "ellps":'WGS84', "datum":'WGS84'},
... always_xy=True,
... )
>>> xpjr, ypjr, zpjr = transprojr.transform(xpj, ypj, zpj, radians=True)
>>> f"{xpjr:.3f} {ypjr:.3f} {zpjr:.3f}"
'-2704026.010 -4253051.810 3895878.820'
>>> transformer = Transformer.from_crs("EPSG:4326", 4326)
>>> xeq, yeq = transformer.transform(33, 98)
>>> f"{xeq:.0f} {yeq:.0f}"
'33 98'
"""
try:
# function optimized for point data
return self._transformer._transform_point(
inx=xx,
iny=yy,
inz=zz,
intime=tt,
direction=direction,
radians=radians,
errcheck=errcheck,
)
except TypeError:
pass
# process inputs, making copies that support buffer API.
inx, x_data_type = _copytobuffer(xx, inplace=inplace)
iny, y_data_type = _copytobuffer(yy, inplace=inplace)
if zz is not None:
inz, z_data_type = _copytobuffer(zz, inplace=inplace)
else:
inz = None
if tt is not None:
intime, t_data_type = _copytobuffer(tt, inplace=inplace)
else:
intime = None
# call pj_transform. inx,iny,inz buffers modified in place.
self._transformer._transform(
inx=inx,
iny=iny,
inz=inz,
intime=intime,
direction=direction,
radians=radians,
errcheck=errcheck,
)
# if inputs were lists, tuples or floats, convert back.
outx = _convertback(x_data_type, inx)
outy = _convertback(y_data_type, iny)
return_data: tuple[Any, ...] = (outx, outy)
if inz is not None:
return_data += (_convertback(z_data_type, inz),)
if intime is not None:
return_data += (_convertback(t_data_type, intime),)
return return_data
def itransform(
self,
points: Any,
switch: bool = False,
time_3rd: bool = False,
radians: bool = False,
errcheck: bool = False,
direction: Union[TransformDirection, str] = TransformDirection.FORWARD,
) -> Iterator[Iterable]:
"""
Iterator/generator version of the function pyproj.Transformer.transform.
See: :c:func:`proj_trans_generic`
.. versionadded:: 2.1.1 errcheck
.. versionadded:: 2.2.0 direction
Parameters
----------
points: list
List of point tuples.
switch: bool, default=False
If True x, y or lon,lat coordinates of points are switched to y, x
or lat, lon. Default is False.
time_3rd: bool, default=False
If the input coordinates are 3 dimensional and the 3rd dimension is time.
radians: bool, default=False
If True, will expect input data to be in radians and will return radians
if the projection is geographic. Otherwise, it uses degrees.
Ignored for pipeline transformations with pyproj 2,
but will work in pyproj 3.
errcheck: bool, default=False
If True, an exception is raised if the errors are found in the process.
If False, ``inf`` is returned for errors.
direction: pyproj.enums.TransformDirection, optional
The direction of the transform.
Default is :attr:`pyproj.enums.TransformDirection.FORWARD`.
Example
--------
>>> from pyproj import Transformer
>>> transformer = Transformer.from_crs(4326, 2100)
>>> points = [(22.95, 40.63), (22.81, 40.53), (23.51, 40.86)]
>>> for pt in transformer.itransform(points): '{:.3f} {:.3f}'.format(*pt)
'2221638.801 2637034.372'
'2212924.125 2619851.898'
'2238294.779 2703763.736'
>>> pipeline_str = (
... "+proj=pipeline +step +proj=longlat +ellps=WGS84 "
... "+step +proj=unitconvert +xy_in=rad +xy_out=deg"
... )
>>> pipe_trans = Transformer.from_pipeline(pipeline_str)
>>> for pt in pipe_trans.itransform([(2.1, 0.001)]):
... '{:.3f} {:.3f}'.format(*pt)
'2.100 0.001'
>>> transproj = Transformer.from_crs(
... {"proj":'geocent', "ellps":'WGS84', "datum":'WGS84'},
... "EPSG:4326",
... always_xy=True,
... )
>>> for pt in transproj.itransform(
... [(-2704026.010, -4253051.810, 3895878.820)],
... radians=True,
... ):
... '{:.3f} {:.3f} {:.3f}'.format(*pt)
'-2.137 0.661 -20.531'
>>> transprojr = Transformer.from_crs(
... "EPSG:4326",
... {"proj":'geocent', "ellps":'WGS84', "datum":'WGS84'},
... always_xy=True,
... )
>>> for pt in transprojr.itransform(
... [(-2.137, 0.661, -20.531)],
... radians=True
... ):
... '{:.3f} {:.3f} {:.3f}'.format(*pt)
'-2704214.394 -4254414.478 3894270.731'
>>> transproj_eq = Transformer.from_crs(
... 'EPSG:4326',
... '+proj=longlat +datum=WGS84 +no_defs +type=crs',
... always_xy=True,
... )
>>> for pt in transproj_eq.itransform([(-2.137, 0.661)]):
... '{:.3f} {:.3f}'.format(*pt)
'-2.137 0.661'
"""
point_it = iter(points) # point iterator
# get first point to check stride
try:
fst_pt = next(point_it)
except StopIteration:
raise ValueError("iterable must contain at least one point") from None
stride = len(fst_pt)
if stride not in (2, 3, 4):
raise ValueError("points can contain up to 4 coordinates")
if time_3rd and stride != 3:
raise ValueError("'time_3rd' is only valid for 3 coordinates.")
# create a coordinate sequence generator etc. x1,y1,z1,x2,y2,z2,....
# chain so the generator returns the first point that was already acquired
coord_gen = chain(
fst_pt, (coords[c] for coords in point_it for c in range(stride))
)
while True:
# create a temporary buffer storage for
# the next 64 points (64*stride*8 bytes)
buff = array("d", islice(coord_gen, 0, 64 * stride))
if len(buff) == 0:
break
self._transformer._transform_sequence(
stride,
buff,
switch=switch,
direction=direction,
time_3rd=time_3rd,
radians=radians,
errcheck=errcheck,
)
yield from zip(*([iter(buff)] * stride))
def transform_bounds(
self,
left: float,
bottom: float,
right: float,
top: float,
densify_pts: int = 21,
radians: bool = False,
errcheck: bool = False,
direction: Union[TransformDirection, str] = TransformDirection.FORWARD,
) -> tuple[float, float, float, float]:
"""
.. versionadded:: 3.1.0
See: :c:func:`proj_trans_bounds`
Transform boundary densifying the edges to account for nonlinear
transformations along these edges and extracting the outermost bounds.
If the destination CRS is geographic and right < left then the bounds
crossed the antimeridian. In this scenario there are two polygons,
one on each side of the antimeridian. The first polygon should be
constructed with (left, bottom, 180, top) and the second with
(-180, bottom, top, right).
To construct the bounding polygons with shapely::
def bounding_polygon(left, bottom, right, top):
if right < left:
return shapely.geometry.MultiPolygon(
[
shapely.geometry.box(left, bottom, 180, top),
shapely.geometry.box(-180, bottom, right, top),
]
)
return shapely.geometry.box(left, bottom, right, top)
Parameters
----------
left: float
Minimum bounding coordinate of the first axis in source CRS
(or the target CRS if using the reverse direction).
bottom: float
Minimum bounding coordinate of the second axis in source CRS.
(or the target CRS if using the reverse direction).
right: float
Maximum bounding coordinate of the first axis in source CRS.
(or the target CRS if using the reverse direction).
top: float
Maximum bounding coordinate of the second axis in source CRS.
(or the target CRS if using the reverse direction).
densify_points: uint, default=21
Number of points to add to each edge to account for nonlinear edges
produced by the transform process. Large numbers will produce worse
performance.
radians: bool, default=False
If True, will expect input data to be in radians and will return radians
if the projection is geographic. Otherwise, it uses degrees.
errcheck: bool, default=False
If True, an exception is raised if the errors are found in the process.
If False, ``inf`` is returned for errors.
direction: pyproj.enums.TransformDirection, optional
The direction of the transform.
Default is :attr:`pyproj.enums.TransformDirection.FORWARD`.
Returns
-------
left, bottom, right, top: float
Outermost coordinates in target coordinate reference system.
"""
return self._transformer._transform_bounds(
left=left,
bottom=bottom,
right=right,
top=top,
densify_pts=densify_pts,
radians=radians,
errcheck=errcheck,
direction=direction,
)
def to_proj4(
self,
version: Union[ProjVersion, str] = ProjVersion.PROJ_5,
pretty: bool = False,
) -> str:
"""
Convert the projection to a PROJ string.
.. versionadded:: 3.1.0
Parameters
----------
version: pyproj.enums.ProjVersion
The version of the PROJ string output.
Default is :attr:`pyproj.enums.ProjVersion.PROJ_5`.
pretty: bool, default=False
If True, it will set the output to be a multiline string.
Returns
-------
str:
The PROJ string.
"""
return self._transformer.to_proj4(version=version, pretty=pretty)
def to_wkt(
self,
version: Union[WktVersion, str] = WktVersion.WKT2_2019,
pretty: bool = False,
) -> str:
"""
Convert the projection to a WKT string.
Version options:
- WKT2_2015
- WKT2_2015_SIMPLIFIED
- WKT2_2019
- WKT2_2019_SIMPLIFIED
- WKT1_GDAL
- WKT1_ESRI
Parameters
----------
version: pyproj.enums.WktVersion, optional
The version of the WKT output.
Default is :attr:`pyproj.enums.WktVersion.WKT2_2019`.
pretty: bool, default=False
If True, it will set the output to be a multiline string.
Returns
-------
str:
The WKT string.
"""
return self._transformer.to_wkt(version=version, pretty=pretty)
def to_json(self, pretty: bool = False, indentation: int = 2) -> str:
"""
Convert the projection to a JSON string.
.. versionadded:: 2.4.0
Parameters
----------
pretty: bool, default=False
If True, it will set the output to be a multiline string.
indentation: int, default=2
If pretty is True, it will set the width of the indentation.
Returns
-------
str:
The JSON string.
"""
return self._transformer.to_json(pretty=pretty, indentation=indentation)
def to_json_dict(self) -> dict:
"""
Convert the projection to a JSON dictionary.
.. versionadded:: 2.4.0
Returns
-------
dict:
The JSON dictionary.
"""
return self._transformer.to_json_dict()
def __str__(self) -> str:
return self.definition
def __repr__(self) -> str:
return (
f"<{self._transformer.type_name}: {self.name}>\n"
f"Description: {self.description}\n"
f"Area of Use:\n{self.area_of_use or '- undefined'}"
)
def __eq__(self, other: Any) -> bool:
if not isinstance(other, Transformer):
return False
return self._transformer.__eq__(other._transformer)
def is_exact_same(self, other: Any) -> bool:
"""
Check if the Transformer objects are the exact same.
If it is not a Transformer, then it returns False.
Parameters
----------
other: Any
Returns
-------
bool
"""
if not isinstance(other, Transformer):
return False
return self._transformer.is_exact_same(other._transformer)
def transform( # pylint: disable=invalid-name
p1: Any,
p2: Any,
x: Any,
y: Any,
z: Optional[Any] = None,
tt: Optional[Any] = None,
radians: bool = False,
errcheck: bool = False,
always_xy: bool = False,
):
"""
.. versionadded:: 2.2.0 always_xy
.. deprecated:: 2.6.1
This function is deprecated. See: :ref:`upgrade_transformer`
x2, y2, z2 = transform(p1, p2, x1, y1, z1)
Transform points between two coordinate systems defined by the
Proj instances p1 and p2.
The points x1,y1,z1 in the coordinate system defined by p1 are
transformed to x2,y2,z2 in the coordinate system defined by p2.
z1 is optional, if it is not set it is assumed to be zero (and
only x2 and y2 are returned). If the optional keyword
'radians' is True (default is False), then all input and
output coordinates will be in radians instead of the default
of degrees for geographic input/output projections.
If the optional keyword 'errcheck' is set to True an
exception is raised if the transformation is
invalid. By default errcheck=False and ``inf`` is returned for an
invalid transformation (and no exception is raised).
If `always_xy` is toggled, the transform method will accept as
input and return as output coordinates using the traditional GIS order,
that is longitude, latitude for geographic CRS and easting,
northing for most projected CRS.
In addition to converting between cartographic and geographic
projection coordinates, this function can take care of datum
shifts (which cannot be done using the __call__ method of the
Proj instances). It also allows for one of the coordinate
systems to be geographic (proj = 'latlong').
x,y and z can be numpy or regular python arrays, python
lists/tuples or scalars. Arrays are fastest. For projections in
geocentric coordinates, values of x and y are given in meters.
z is always meters.
"""
warnings.warn(
(
"This function is deprecated. "
"See: https://pyproj4.github.io/pyproj/stable/"
"gotchas.html#upgrading-to-pyproj-2-from-pyproj-1"
),
FutureWarning,
stacklevel=2,
)
return Transformer.from_proj(p1, p2, always_xy=always_xy).transform(
xx=x, yy=y, zz=z, tt=tt, radians=radians, errcheck=errcheck
)
def itransform( # pylint: disable=invalid-name
p1: Any,
p2: Any,
points: Iterable[Iterable],
switch: bool = False,
time_3rd: bool = False,
radians: bool = False,
errcheck: bool = False,
always_xy: bool = False,
):
"""
.. versionadded:: 2.2.0 always_xy
.. deprecated:: 2.6.1
This function is deprecated. See: :ref:`upgrade_transformer`
points2 = itransform(p1, p2, points1)
Iterator/generator version of the function pyproj.transform.
Transform points between two coordinate systems defined by the
Proj instances p1 and p2. This function can be used as an alternative
to pyproj.transform when there is a need to transform a big number of
coordinates lazily, for example when reading and processing from a file.
Points1 is an iterable/generator of coordinates x1,y1(,z1) or lon1,lat1(,z1)
in the coordinate system defined by p1. Points2 is an iterator that returns tuples
of x2,y2(,z2) or lon2,lat2(,z2) coordinates in the coordinate system defined by p2.
z are provided optionally.
Points1 can be:
- a tuple/list of tuples/lists i.e. for 2d points: [(xi,yi),(xj,yj),....(xn,yn)]
- a Nx3 or Nx2 2d numpy array where N is the point number
- a generator of coordinates (xi,yi) for 2d points or (xi,yi,zi) for 3d
If optional keyword 'switch' is True (default is False) then x, y or lon,lat
coordinates of points are switched to y, x or lat, lon.
If the optional keyword 'radians' is True (default is False),
then all input and output coordinates will be in radians instead
of the default of degrees for geographic input/output projections.
If the optional keyword 'errcheck' is set to True an
exception is raised if the transformation is
invalid. By default errcheck=False and ``inf`` is returned for an
invalid transformation (and no exception is raised).
If `always_xy` is toggled, the transform method will accept as
input and return as output coordinates using the traditional GIS order,
that is longitude, latitude for geographic CRS and easting, northing
for most projected CRS.
Example usage:
>>> from pyproj import Proj, itransform
>>> # projection 1: WGS84
>>> # (defined by epsg code 4326)
>>> p1 = Proj('epsg:4326', preserve_units=False)
>>> # projection 2: GGRS87 / Greek Grid
>>> p2 = Proj('epsg:2100', preserve_units=False)
>>> # Three points with coordinates lon, lat in p1
>>> points = [(22.95, 40.63), (22.81, 40.53), (23.51, 40.86)]
>>> # transform this point to projection 2 coordinates.
>>> for pt in itransform(p1,p2,points, always_xy=True): '%6.3f %7.3f' % pt
'411050.470 4497928.574'
'399060.236 4486978.710'
'458553.243 4523045.485'
>>> for pt in itransform(4326, 4326, [(30, 60)]):
... '{:.0f} {:.0f}'.format(*pt)
'30 60'
"""
warnings.warn(
(
"This function is deprecated. "
"See: https://pyproj4.github.io/pyproj/stable/"
"gotchas.html#upgrading-to-pyproj-2-from-pyproj-1"
),
FutureWarning,
stacklevel=2,
)
return Transformer.from_proj(p1, p2, always_xy=always_xy).itransform(
points, switch=switch, time_3rd=time_3rd, radians=radians, errcheck=errcheck
)
pyproj-3.6.1/pyproj/utils.py 0000664 0000000 0000000 00000010571 14502715416 0016112 0 ustar 00root root 0000000 0000000 """
Utility functions used within pyproj
"""
import json
from array import array
from enum import Enum, auto
from typing import Any
def is_null(value: Any) -> bool:
"""
Check if value is NaN or None
"""
# pylint: disable=comparison-with-itself
return value != value or value is None
def strtobool(value: Any) -> bool:
"""
https://docs.python.org/3.9/distutils/apiref.html#distutils.util.strtobool
Here since distutils is deprecated.
Convert a string representation of truth to True or False.
"""
value = str(value).lower()
if value in ("y", "yes", "t", "true", "on", "1"):
return True
if value in ("n", "no", "f", "false", "off", "0"):
return False
raise ValueError(f"invalid truth value: '{value}'")
class NumpyEncoder(json.JSONEncoder):
"""
Handle numpy types when dumping to JSON
"""
def default(self, obj): # pylint: disable=arguments-renamed
try:
return obj.tolist()
except AttributeError:
pass
try:
# numpy scalars
if obj.dtype.kind == "f":
return float(obj)
if obj.dtype.kind == "i":
return int(obj)
except AttributeError:
pass
return json.JSONEncoder.default(self, obj)
class DataType(Enum):
"""
Data type for copy to buffer and convertback operations
"""
FLOAT = auto()
LIST = auto()
TUPLE = auto()
ARRAY = auto()
def _copytobuffer_return_scalar(xxx: Any) -> tuple[array, DataType]:
"""
Prepares scalar for PROJ C-API:
- Makes a copy because PROJ modifies buffer in place
- Make sure dtype is double as that is what PROJ expects
- Makes sure object supports Python Buffer API
Parameters
-----------
xxx: float or 0-d numpy array
Returns
-------
tuple[Any, DataType]
The copy of the data prepared for the PROJ API & Python Buffer API.
"""
try:
return array("d", (float(xxx),)), DataType.FLOAT
except Exception:
raise TypeError("input must be a scalar") from None
def _copytobuffer(xxx: Any, inplace: bool = False) -> tuple[Any, DataType]:
"""
Prepares data for PROJ C-API:
- Makes a copy because PROJ modifies buffer in place
- Make sure dtype is double as that is what PROJ expects
- Makes sure object supports Python Buffer API
If the data is a numpy array, it ensures the data is in C order.
Parameters
----------
xxx: Any
A scalar, list, tuple, numpy.array,
pandas.Series, xaray.DataArray, or dask.array.Array.
inplace: bool, default=False
If True, will return the array without a copy if it
meets the requirements of the Python Buffer API & PROJ C-API.
Returns
-------
tuple[Any, DataType]
The copy of the data prepared for the PROJ API & Python Buffer API.
"""
# check for pandas.Series, xarray.DataArray or dask.array.Array
# also handle numpy masked Arrays; note that pandas.Series also has a
# "mask" attribute, hence checking for simply the "mask" attr in that
# case isn't sufficient
if (
not hasattr(xxx, "hardmask")
and hasattr(xxx, "__array__")
and callable(xxx.__array__)
):
xxx = xxx.__array__()
# handle numpy data
if hasattr(xxx, "shape"):
if xxx.shape == ():
# convert numpy array scalar to float
# (array scalars don't support buffer API)
return _copytobuffer_return_scalar(xxx)
# Use C order when copying to handle arrays in fortran order
return xxx.astype("d", order="C", copy=not inplace), DataType.ARRAY
data_type = DataType.ARRAY
if isinstance(xxx, array):
if not inplace or xxx.typecode != "d":
xxx = array("d", xxx)
elif isinstance(xxx, list):
xxx = array("d", xxx)
data_type = DataType.LIST
elif isinstance(xxx, tuple):
xxx = array("d", xxx)
data_type = DataType.TUPLE
else:
return _copytobuffer_return_scalar(xxx)
return xxx, data_type
def _convertback(data_type: DataType, inx: Any) -> Any:
# if inputs were lists, tuples or floats, convert back to original type.
if data_type == DataType.FLOAT:
return inx[0]
if data_type == DataType.LIST:
return inx.tolist()
if data_type == DataType.TUPLE:
return tuple(inx)
return inx
pyproj-3.6.1/pyproject.toml 0000664 0000000 0000000 00000003575 14502715416 0015777 0 ustar 00root root 0000000 0000000 [build-system]
requires = ["setuptools>=61.0.0", "wheel", "cython>=3"]
build-backend = "setuptools.build_meta"
[project]
name = "pyproj"
dynamic = ["version"]
description = "Python interface to PROJ (cartographic projections and coordinate transformations library)"
readme = "README.md"
authors = [
{name = "Jeff Whitaker", email = "jeffrey.s.whitaker@noaa.gov"},
]
maintainers = [
{name = "pyproj contributors"},
]
license = {text = "MIT"}
keywords = [
"GIS",
"map",
"geospatial",
"coordinate-systems",
"coordinate-transformation",
"cartographic-projection",
"geodesic",
]
classifiers = [
"Development Status :: 4 - Beta",
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Programming Language :: Python :: 3 :: Only",
"Topic :: Scientific/Engineering",
"Topic :: Scientific/Engineering :: GIS",
"Topic :: Scientific/Engineering :: Mathematics",
"Topic :: Software Development :: Libraries :: Python Modules",
"Typing :: Typed",
]
requires-python = ">=3.9"
dependencies = [
"certifi",
]
[project.urls]
homepage = "https://pyproj4.github.io/pyproj/"
documentation = "https://pyproj4.github.io/pyproj/"
repository = "https://github.com/pyproj4/pyproj"
changelog = "https://pyproj4.github.io/pyproj/stable/history.html"
[project.scripts]
pyproj = "pyproj.__main__:main"
[tool.setuptools]
zip-safe = false # https://mypy.readthedocs.io/en/stable/installed_packages.html
[tool.setuptools.packages.find]
include = ["pyproj", "pyproj.*"]
[tool.setuptools.dynamic]
version = {attr = "pyproj.__version__"}
[tool.black]
target_version = ["py39"]
pyproj-3.6.1/pytest.ini 0000664 0000000 0000000 00000000521 14502715416 0015100 0 ustar 00root root 0000000 0000000 [pytest]
markers =
slow: marks tests as slow (deselect with '-m "not slow"')
network: marks tests that need a network connection (deselect with '-m "not network"')
cli: marks tests that need the CLI installed (deselect with '-m "not cli"')
grid: marks tests that need transformation grids (deselect with '-m "not grid"')
pyproj-3.6.1/requirements-dev.txt 0000664 0000000 0000000 00000000055 14502715416 0017111 0 ustar 00root root 0000000 0000000 cython>=0.28.4
mypy
types-certifi
pre-commit
pyproj-3.6.1/requirements-docs.txt 0000664 0000000 0000000 00000000044 14502715416 0017261 0 ustar 00root root 0000000 0000000 furo>=2022.6
sphinx
sphinx-argparse
pyproj-3.6.1/requirements-test.txt 0000664 0000000 0000000 00000000201 14502715416 0017303 0 ustar 00root root 0000000 0000000 packaging
pytest>3.6
pytest-cov
numpy
pandas; python_version<'3.12'
shapely; python_version<'3.12'
xarray; python_version<'3.12'
pyproj-3.6.1/setup.py 0000664 0000000 0000000 00000020727 14502715416 0014573 0 ustar 00root root 0000000 0000000 import os
import platform
import re
import shutil
import subprocess
import sys
from pathlib import Path
from typing import Optional
from setuptools import Extension, setup
PROJ_MIN_VERSION = (9, 0, 0)
CURRENT_FILE_PATH = Path(__file__).absolute().parent
BASE_INTERNAL_PROJ_DIR = Path("proj_dir")
INTERNAL_PROJ_DIR = CURRENT_FILE_PATH / "pyproj" / BASE_INTERNAL_PROJ_DIR
PROJ_VERSION_SEARCH = re.compile(r".*Rel\.\s+(?P\d+\.\d+\.\d+).*")
VERSION_SEARCH = re.compile(r".*(?P\d+\.\d+\.\d+).*")
def _parse_version(version: str) -> tuple[int, int, int]:
"""Convert a version string to a tuple of integers."""
match = VERSION_SEARCH.search(version)
if not match:
raise SystemExit(
f"PROJ version unable to be determined from {version}. "
"Please set the PROJ_VERSION environment variable."
)
return tuple(
int(ver) for ver in match.groupdict()["version"].split(".", maxsplit=2)
)
def get_proj_version(proj_dir: Path) -> tuple[int, int, int]:
"""
Determine PROJ version.
Prefer PROJ_VERSION environment variable.
If PROJ_VERSION is not set, try to determine the version from the PROJ executable.
"""
proj_version = os.environ.get("PROJ_VERSION")
if proj_version:
return _parse_version(proj_version)
proj = proj_dir / "bin" / "proj"
proj_ver = subprocess.check_output(str(proj), stderr=subprocess.STDOUT).decode(
"ascii"
)
match = PROJ_VERSION_SEARCH.search(proj_ver)
if not match:
raise SystemExit(
"PROJ version unable to be determined. "
"Please set the PROJ_VERSION environment variable."
)
return _parse_version(match.groupdict()["version"])
def check_proj_version(proj_version: tuple[int, int, int]) -> None:
"""checks that the PROJ library meets the minimum version"""
if proj_version < PROJ_MIN_VERSION:
proj_version_str = ".".join(str(ver) for ver in proj_version)
min_proj_version_str = ".".join(str(ver) for ver in PROJ_MIN_VERSION)
raise SystemExit(
f"ERROR: Minimum supported PROJ version is {min_proj_version_str}, "
f"installed version is {proj_version_str}. For more information see: "
"https://pyproj4.github.io/pyproj/stable/installation.html"
)
def get_proj_dir() -> Path:
"""
This function finds the base PROJ directory.
"""
proj_dir_environ = os.environ.get("PROJ_DIR")
proj_dir: Optional[Path] = None
if proj_dir_environ is not None:
proj_dir = Path(proj_dir_environ)
if proj_dir is None and INTERNAL_PROJ_DIR.exists():
proj_dir = INTERNAL_PROJ_DIR
print(f"Internally compiled directory being used {INTERNAL_PROJ_DIR}.")
elif proj_dir is None and not INTERNAL_PROJ_DIR.exists():
proj = shutil.which("proj", path=sys.prefix)
if proj is None:
proj = shutil.which("proj")
if proj is None:
raise SystemExit(
"proj executable not found. Please set the PROJ_DIR variable. "
"For more information see: "
"https://pyproj4.github.io/pyproj/stable/installation.html"
)
proj_dir = Path(proj).parent.parent
elif proj_dir is not None and proj_dir.exists():
print("PROJ_DIR is set, using existing PROJ installation..\n")
else:
raise SystemExit(f"ERROR: Invalid path for PROJ_DIR {proj_dir}")
return proj_dir
def get_proj_libdirs(proj_dir: Path) -> list[str]:
"""
This function finds the library directories
"""
proj_libdir = os.environ.get("PROJ_LIBDIR")
libdirs = []
if proj_libdir is None:
libdir_search_paths = (proj_dir / "lib", proj_dir / "lib64")
for libdir_search_path in libdir_search_paths:
if libdir_search_path.exists():
libdirs.append(str(libdir_search_path))
if not libdirs:
raise SystemExit(
"ERROR: PROJ_LIBDIR dir not found. Please set PROJ_LIBDIR."
)
else:
libdirs.append(proj_libdir)
return libdirs
def get_proj_incdirs(proj_dir: Path) -> list[str]:
"""
This function finds the include directories
"""
proj_incdir = os.environ.get("PROJ_INCDIR")
incdirs = []
if proj_incdir is None:
if (proj_dir / "include").exists():
incdirs.append(str(proj_dir / "include"))
else:
raise SystemExit(
"ERROR: PROJ_INCDIR dir not found. Please set PROJ_INCDIR."
)
else:
incdirs.append(proj_incdir)
return incdirs
def get_cythonize_options():
"""
This function gets the options to cythonize with
"""
# Configure optional Cython coverage.
cythonize_options = {
"language_level": sys.version_info[0],
"compiler_directives": {
"c_string_type": "str",
"c_string_encoding": "utf-8",
"embedsignature": True,
},
}
if os.environ.get("PYPROJ_FULL_COVERAGE"):
cythonize_options["compiler_directives"].update(linetrace=True)
cythonize_options["annotate"] = True
return cythonize_options
def get_libraries(libdirs: list[str]) -> list[str]:
"""
This function gets the libraries to cythonize with
"""
libraries = ["proj"]
if os.name == "nt":
for libdir in libdirs:
projlib = list(Path(libdir).glob("proj*.lib"))
if projlib:
libraries = [str(projlib[0].stem)]
break
return libraries
def get_extension_modules():
"""
This function retrieves the extension modules
"""
if "clean" in sys.argv:
return None
# make sure cython is available
try:
from Cython.Build import cythonize
except ImportError as error:
raise SystemExit(
"ERROR: Cython.Build.cythonize not found. "
"Cython is required to build pyproj."
) from error
# By default we'll try to get options PROJ_DIR or the local version of proj
proj_dir = get_proj_dir()
library_dirs = get_proj_libdirs(proj_dir)
include_dirs = get_proj_incdirs(proj_dir)
proj_version = get_proj_version(proj_dir)
check_proj_version(proj_version)
proj_version_major, proj_version_minor, proj_version_patch = proj_version
# setup extension options
ext_options = {
"include_dirs": include_dirs,
"library_dirs": library_dirs,
"runtime_library_dirs": (
library_dirs if os.name != "nt" and sys.platform != "cygwin" else None
),
"libraries": get_libraries(library_dirs),
}
# setup cythonized modules
return cythonize(
[
Extension("pyproj._geod", ["pyproj/_geod.pyx"], **ext_options),
Extension("pyproj._crs", ["pyproj/_crs.pyx"], **ext_options),
Extension(
"pyproj._transformer", ["pyproj/_transformer.pyx"], **ext_options
),
Extension("pyproj._compat", ["pyproj/_compat.pyx"], **ext_options),
Extension("pyproj.database", ["pyproj/database.pyx"], **ext_options),
Extension("pyproj._datadir", ["pyproj/_datadir.pyx"], **ext_options),
Extension("pyproj.list", ["pyproj/list.pyx"], **ext_options),
Extension("pyproj._network", ["pyproj/_network.pyx"], **ext_options),
Extension("pyproj._sync", ["pyproj/_sync.pyx"], **ext_options),
],
quiet=True,
compile_time_env={
"CTE_PROJ_VERSION_MAJOR": proj_version_major,
"CTE_PROJ_VERSION_MINOR": proj_version_minor,
"CTE_PROJ_VERSION_PATCH": proj_version_patch,
"CTE_PYTHON_IMPLEMENTATION": platform.python_implementation(),
},
**get_cythonize_options(),
)
def get_package_data() -> dict[str, list[str]]:
"""
This function retrieves the package data
"""
# setup package data
package_data = {"pyproj": ["*.pyi", "py.typed"]}
if os.environ.get("PROJ_WHEEL") is not None and INTERNAL_PROJ_DIR.exists():
package_data["pyproj"].append(
str(BASE_INTERNAL_PROJ_DIR / "share" / "proj" / "*")
)
if (
os.environ.get("PROJ_WHEEL") is not None
and (CURRENT_FILE_PATH / "pyproj" / ".lib").exists()
):
package_data["pyproj"].append(os.path.join(".lib", "*"))
return package_data
# static items in pyproject.toml
setup(
ext_modules=get_extension_modules(),
package_data=get_package_data(),
# temptorary hack to add in metadata
url="https://github.com/pyproj4/pyproj",
)
pyproj-3.6.1/test/ 0000775 0000000 0000000 00000000000 14502715416 0014030 5 ustar 00root root 0000000 0000000 pyproj-3.6.1/test/__init__.py 0000664 0000000 0000000 00000000000 14502715416 0016127 0 ustar 00root root 0000000 0000000 pyproj-3.6.1/test/conftest.py 0000664 0000000 0000000 00000006065 14502715416 0016236 0 ustar 00root root 0000000 0000000 import os
import pickle
from contextlib import contextmanager
from pathlib import Path
import numpy
import pytest
from packaging import version
import pyproj
from pyproj.datadir import get_data_dir, get_user_data_dir, set_data_dir
_NETWORK_ENABLED = pyproj.network.is_network_enabled()
PROJ_LOOSE_VERSION = version.parse(pyproj.__proj_version__)
PROJ_911 = PROJ_LOOSE_VERSION == version.parse("9.1.1")
PROJ_GTE_901 = PROJ_LOOSE_VERSION >= version.parse("9.0.1")
PROJ_GTE_91 = PROJ_LOOSE_VERSION >= version.parse("9.1")
PROJ_GTE_911 = PROJ_LOOSE_VERSION >= version.parse("9.1.1")
PROJ_GTE_92 = PROJ_LOOSE_VERSION >= version.parse("9.2.0")
PROJ_GTE_921 = PROJ_LOOSE_VERSION >= version.parse("9.2.1")
PROJ_GTE_93 = PROJ_LOOSE_VERSION >= version.parse("9.3.0")
def unset_data_dir():
pyproj.datadir._USER_PROJ_DATA = None
pyproj.datadir._VALIDATED_PROJ_DATA = None
@contextmanager
def proj_network_env():
"""
Ensure global context network settings reset
"""
try:
yield
finally:
pyproj.network.set_network_enabled(_NETWORK_ENABLED)
@contextmanager
def proj_env():
"""
Ensure environment variable the same at the end of the test.
"""
unset_data_dir()
try:
yield
finally:
# make sure the data dir is cleared
unset_data_dir()
# reset back to the original path
set_data_dir(get_data_dir())
@contextmanager
def tmp_chdir(new_dir):
"""
This temporarily changes directories when running the tests.
Useful for when testing wheels in the pyproj directory
when pyproj has not been build and prevents conflicts.
"""
curdir = os.getcwd()
try:
os.chdir(new_dir)
yield
finally:
os.chdir(curdir)
def grids_available(*grid_names, check_network=True, check_all=False):
"""
Check if the grids are available
"""
if check_network and pyproj.network.is_network_enabled():
return True
available = [
(
Path(get_data_dir(), grid_name).exists()
or Path(get_user_data_dir(), grid_name).exists()
)
for grid_name in grid_names
]
if check_all:
return all(available)
return any(available)
def assert_can_pickle(raw_obj, tmp_path):
file_path = tmp_path / "temporary.pickle"
with open(file_path, "wb") as f:
pickle.dump(raw_obj, f)
with open(file_path, "rb") as f:
unpickled = pickle.load(f)
assert raw_obj == unpickled
def _make_1_element_array(data: float):
"""
Turn the float into a 1-element array
"""
return numpy.array([data])
def _make_2_element_array(data: float):
"""
Turn the float into a 2-element array
"""
return numpy.array([data] * 2)
@pytest.fixture(
params=[
float,
numpy.array,
_make_1_element_array,
_make_2_element_array,
]
)
def scalar_and_array(request):
"""
Ensure cython methods are tested
with scalar and arrays to trigger
point optimized functions as well
as the main functions supporting arrays.
"""
return request.param
pyproj-3.6.1/test/crs/ 0000775 0000000 0000000 00000000000 14502715416 0014617 5 ustar 00root root 0000000 0000000 pyproj-3.6.1/test/crs/test_crs.py 0000664 0000000 0000000 00000154465 14502715416 0017036 0 ustar 00root root 0000000 0000000 import concurrent.futures
import json
import platform
from unittest.mock import patch
import numpy
import pytest
import pyproj
from pyproj import CRS
from pyproj._crs import AuthorityMatchInfo
from pyproj.crs import (
CoordinateOperation,
CoordinateSystem,
Datum,
Ellipsoid,
PrimeMeridian,
)
from pyproj.crs.enums import CoordinateOperationType, DatumType
from pyproj.enums import ProjVersion, WktVersion
from pyproj.exceptions import CRSError
from pyproj.transformer import TransformerGroup
from test.conftest import (
PROJ_GTE_91,
PROJ_GTE_901,
PROJ_GTE_911,
PROJ_GTE_921,
assert_can_pickle,
grids_available,
)
class CustomCRS:
def to_wkt(self):
return CRS.from_epsg(4326).to_wkt()
def test_from_proj4_json():
json_str = '{"proj": "longlat", "ellps": "WGS84", "datum": "WGS84"}'
proj = CRS.from_string(json_str)
with pytest.warns(UserWarning):
assert proj.to_proj4(4) == "+proj=longlat +datum=WGS84 +no_defs +type=crs"
assert proj.to_proj4(5) == "+proj=longlat +datum=WGS84 +no_defs +type=crs"
# Test with invalid JSON code
with pytest.raises(CRSError):
assert CRS.from_string("{foo: bar}")
def test_from_proj4():
proj = CRS.from_proj4("+proj=longlat +datum=WGS84 +no_defs +type=crs")
with pytest.warns(UserWarning):
assert proj.to_proj4() == "+proj=longlat +datum=WGS84 +no_defs +type=crs"
def test_from_proj4__invalid():
# Test with invalid JSON code
with pytest.raises(CRSError):
assert CRS.from_proj4(CRS(3857).to_wkt())
def test_from_epsg():
proj = CRS.from_epsg(4326)
assert proj.to_epsg() == 4326
# Test with invalid EPSG code
with pytest.raises(CRSError):
assert CRS.from_epsg(0)
def test_from_epsg_string():
proj = CRS.from_string("epsg:4326")
assert proj.to_epsg() == 4326
# Test with invalid EPSG code
with pytest.raises(CRSError):
assert CRS.from_string("epsg:xyz")
def test_from_epsg_int_like_string():
proj = CRS.from_string("4326")
assert proj.to_epsg() == 4326
# Test with invalid EPSG code
with pytest.raises(CRSError):
assert CRS.from_string("0")
def test_from_string():
wgs84_crs = CRS.from_string("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
with pytest.warns(UserWarning):
assert wgs84_crs.to_proj4() == "+proj=longlat +datum=WGS84 +no_defs +type=crs"
# Make sure this doesn't get handled using the from_epsg()
# even though 'epsg' is in the string
with pytest.warns(FutureWarning):
epsg_init_crs = CRS.from_string("+init=epsg:26911 +units=m +no_defs=True")
with pytest.warns(UserWarning):
assert (
epsg_init_crs.to_proj4()
== "+proj=utm +zone=11 +datum=NAD83 +units=m +no_defs +type=crs"
)
def test_from_numpy():
crs_numpy = numpy.array([4326])[0]
proj = CRS.from_user_input(crs_numpy)
assert proj.to_epsg() == 4326
# Test with invalid EPSG code
with pytest.raises(CRSError):
crs_numpy = numpy.array([0])[0]
assert CRS.from_epsg(crs_numpy)
def test_from_string__invalid():
with pytest.raises(CRSError, match="CRS input is not a string"):
CRS.from_string(4326)
def test_initialize_projparams_with_kwargs():
crs_mixed_args = CRS("+proj=utm +zone=10", ellps="WGS84")
crs_positional = CRS("+proj=utm +zone=10 +ellps=WGS84")
assert crs_mixed_args.is_exact_same(crs_positional)
def test_bare_parameters():
"""Make sure that bare parameters (e.g., no_defs) are handled properly,
even if they come in with key=True. This covers interaction with pyproj,
which makes presents bare parameters as key=."""
# Example produced by pyproj
proj = CRS.from_string(
"+proj=lcc +lon_0=-95 +ellps=GRS80 +y_0=0 +no_defs=True "
"+x_0=0 +units=m +lat_2=77 +lat_1=49 +lat_0=0"
)
with pytest.warns(UserWarning):
assert "+no_defs" in proj.to_proj4(4)
# TODO: THIS DOES NOT WORK
proj = CRS.from_string(
"+lon_0=-95 +ellps=GRS80 +proj=lcc +y_0=0 +no_defs=False "
"+x_0=0 +units=m +lat_2=77 +lat_1=49 +lat_0=0"
)
# assert "+no_defs" not in proj.to_proj4(4)
def test_is_geographic():
assert CRS("EPSG:4326").is_geographic is True
assert CRS("EPSG:3857").is_geographic is False
wgs84_crs = CRS.from_string("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
assert wgs84_crs.is_geographic is True
nad27_crs = CRS.from_string("+proj=longlat +ellps=clrk66 +datum=NAD27 +no_defs")
assert nad27_crs.is_geographic is True
lcc_crs = CRS.from_string(
"+lon_0=-95 +ellps=GRS80 +y_0=0 +no_defs=True +proj=lcc +x_0=0 "
"+units=m +lat_2=77 +lat_1=49 +lat_0=0"
)
assert lcc_crs.is_geographic is False
def test_is_projected():
assert CRS("EPSG:3857").is_projected is True
lcc_crs = CRS.from_string(
"+lon_0=-95 +ellps=GRS80 +y_0=0 +no_defs=True +proj=lcc +x_0=0 "
"+units=m +lat_2=77 +lat_1=49 +lat_0=0"
)
assert CRS.from_user_input(lcc_crs).is_projected is True
wgs84_crs = CRS.from_string("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
assert CRS.from_user_input(wgs84_crs).is_projected is False
def test_is_compound():
assert CRS("EPSG:4326+5773").is_compound
assert not CRS("EPSG:4326").is_compound
def test_is_same_crs():
crs1 = CRS("urn:ogc:def:crs:OGC::CRS84")
crs2 = CRS("EPSG:3857")
assert crs1 == crs1
assert crs1 != crs2
wgs84_crs = CRS.from_string("+proj=longlat +ellps=WGS84 +datum=WGS84")
assert crs1 == wgs84_crs
# Make sure that same projection with different parameter are not equal
lcc_crs1 = CRS.from_string(
"+lon_0=-95 +ellps=GRS80 +y_0=0 +no_defs=True +proj=lcc "
"+x_0=0 +units=m +lat_2=77 +lat_1=49 +lat_0=0"
)
lcc_crs2 = CRS.from_string(
"+lon_0=-95 +ellps=GRS80 +y_0=0 +no_defs=True +proj=lcc "
"+x_0=0 +units=m +lat_2=77 +lat_1=45 +lat_0=0"
)
assert lcc_crs1 != lcc_crs2
def test_to_proj4():
with pytest.warns(UserWarning):
assert (
CRS("EPSG:4326").to_proj4(4)
== "+proj=longlat +datum=WGS84 +no_defs +type=crs"
)
def test_empty_json():
with pytest.raises(CRSError):
CRS.from_string("{}")
with pytest.raises(CRSError):
CRS.from_string("[]")
with pytest.raises(CRSError):
CRS.from_string("")
def test_has_wkt_property():
with pytest.warns(FutureWarning):
assert (
CRS({"init": "EPSG:4326"})
.to_wkt("WKT1_GDAL")
.startswith('GEOGCS["WGS 84",DATUM')
)
def test_to_wkt_pretty():
crs = CRS.from_epsg(4326)
assert "\n" in crs.to_wkt(pretty=True)
assert "\n" not in crs.to_wkt()
@pytest.mark.parametrize(
"version, expected",
[
("WKT1_GDAL", False),
("WKT1_ESRI", False),
("WKT2_2019", True),
],
)
def test_to_wkt_with_axis_rule_4326(version, expected):
crs = CRS.from_epsg(4326)
axis = "AXIS"
assert (axis in crs.to_wkt(version)) == expected
assert (axis in crs.to_wkt(version, output_axis_rule=None)) == expected
assert axis in crs.to_wkt(version, output_axis_rule=True)
assert axis not in crs.to_wkt(version, output_axis_rule=False)
@pytest.mark.parametrize(
"version, expected",
[
("WKT1_GDAL", True),
("WKT1_ESRI", False),
("WKT2_2019", True),
],
)
def test_to_wkt_with_axis_rule_32630(version, expected):
crs = CRS.from_epsg(32630)
axis = "AXIS"
assert (axis in crs.to_wkt(version)) == expected
assert (axis in crs.to_wkt(version, output_axis_rule=None)) == expected
assert axis in crs.to_wkt(version, output_axis_rule=True)
assert axis not in crs.to_wkt(version, output_axis_rule=False)
def test_repr():
with pytest.warns(FutureWarning):
assert repr(CRS({"init": "EPSG:4326"})) == (
"\n"
"Name: WGS 84\n"
"Axis Info [ellipsoidal]:\n"
"- lon[east]: Longitude (degree)\n"
"- lat[north]: Latitude (degree)\n"
"Area of Use:\n"
"- name: World.\n"
"- bounds: (-180.0, -90.0, 180.0, 90.0)\n"
"Datum: World Geodetic System 1984 ensemble\n"
"- Ellipsoid: WGS 84\n"
"- Prime Meridian: Greenwich\n"
)
def test_repr__long():
with pytest.warns(FutureWarning):
wkt_str = 'GEOGCRS["WGS 84",ENSEMBLE["World Geodetic System 1'
assert repr(CRS(CRS({"init": "EPSG:4326"}).to_wkt())) == (
f"\n"
"Name: WGS 84\n"
"Axis Info [ellipsoidal]:\n"
"- lon[east]: Longitude (degree)\n"
"- lat[north]: Latitude (degree)\n"
"Area of Use:\n"
"- name: World.\n"
"- bounds: (-180.0, -90.0, 180.0, 90.0)\n"
"Datum: World Geodetic System 1984 ensemble\n"
"- Ellipsoid: WGS 84\n"
"- Prime Meridian: Greenwich\n"
)
def test_repr_epsg():
assert repr(CRS(CRS("EPSG:4326").to_wkt())) == (
"\n"
"Name: WGS 84\n"
"Axis Info [ellipsoidal]:\n"
"- Lat[north]: Geodetic latitude (degree)\n"
"- Lon[east]: Geodetic longitude (degree)\n"
"Area of Use:\n"
"- name: World.\n"
"- bounds: (-180.0, -90.0, 180.0, 90.0)\n"
"Datum: World Geodetic System 1984 ensemble\n"
"- Ellipsoid: WGS 84\n"
"- Prime Meridian: Greenwich\n"
)
def test_repr__undefined():
datum_name = "unknown"
if PROJ_GTE_901:
datum_name = f"{datum_name} using nadgrids=@null"
assert repr(
CRS(
"+proj=merc +a=6378137.0 +b=6378137.0 +nadgrids=@null"
" +lon_0=0.0 +x_0=0.0 +y_0=0.0 +units=m +no_defs"
)
) == (
"\n"
"Name: unknown\n"
"Axis Info [cartesian]:\n"
"- E[east]: Easting (metre)\n"
"- N[north]: Northing (metre)\n"
"Area of Use:\n"
"- undefined\n"
"Coordinate Operation:\n"
"- name: unknown to WGS84\n"
"- method: NTv2\n"
f"Datum: {datum_name}\n"
"- Ellipsoid: unknown\n"
"- Prime Meridian: Greenwich\n"
"Source CRS: unknown\n"
)
def test_repr_compound():
assert repr(CRS.from_epsg(3901)) == (
"\n"
"Name: KKJ / Finland Uniform Coordinate System + N60 height\n"
"Axis Info [cartesian|vertical]:\n"
"- X[north]: Northing (metre)\n"
"- Y[east]: Easting (metre)\n"
"- H[up]: Gravity-related height (metre)\n"
"Area of Use:\n"
"- name: Finland - onshore.\n"
"- bounds: (19.24, 59.75, 31.59, 70.09)\n"
"Datum: Kartastokoordinaattijarjestelma (1966)\n"
"- Ellipsoid: International 1924\n"
"- Prime Meridian: Greenwich\n"
"Sub CRS:\n"
"- KKJ / Finland Uniform Coordinate System\n"
"- N60 height\n"
)
def test_axis_info_compound():
assert [axis.direction for axis in CRS.from_epsg(3901).axis_info] == [
"north",
"east",
"up",
]
def test_dunder_str():
with pytest.warns(FutureWarning):
assert str(CRS({"init": "EPSG:4326"})) == CRS({"init": "EPSG:4326"}).srs
def test_epsg():
with pytest.warns(FutureWarning):
assert CRS({"init": "EPSG:4326"}).to_epsg(20) == 4326
assert CRS({"init": "EPSG:4326"}).to_epsg() is None
assert CRS.from_user_input(4326).to_epsg() == 4326
assert CRS.from_epsg(4326).to_epsg() == 4326
assert CRS.from_user_input("epsg:4326").to_epsg() == 4326
def test_datum():
datum = CRS.from_epsg(4326).datum
assert "\n" in repr(datum)
datum_wkt = 'ENSEMBLE["World Geodetic System 1984 ensemble"'
assert repr(datum).startswith(datum_wkt)
assert datum.to_wkt().startswith(datum_wkt)
assert datum == datum
assert datum.is_exact_same(datum)
def test_datum_horizontal():
assert CRS.from_epsg(5972).datum == CRS.from_epsg(25832).datum
def test_datum_unknown():
crs = CRS(
"+proj=omerc +lat_0=-36.10360962430914 "
"+lonc=147.06322917270154 +alpha=-54.786229796129035 "
"+k=1 +x_0=0 +y_0=0 +gamma=0 +ellps=WGS84 "
"+towgs84=0,0,0,0,0,0,0 +units=m +no_defs"
)
datum_name = "Unknown based on WGS84 ellipsoid"
if PROJ_GTE_921:
datum_name = "Unknown based on WGS 84 ellipsoid"
if PROJ_GTE_901:
datum_name = f"{datum_name} using towgs84=0,0,0,0,0,0,0"
assert crs.datum.name == datum_name
def test_epsg__not_found():
assert CRS("+proj=longlat +datum=WGS84 +no_defs +towgs84=0,0,0").to_epsg(0) is None
assert (
CRS.from_string("+proj=longlat +datum=WGS84 +no_defs +towgs84=0,0,0").to_epsg()
is None
)
def test_epsg__no_code_available():
lcc_crs = CRS.from_string(
"+lon_0=-95 +ellps=GRS80 +y_0=0 +no_defs=True +proj=lcc "
"+x_0=0 +units=m +lat_2=77 +lat_1=49 +lat_0=0"
)
assert lcc_crs.to_epsg() is None
def test_crs_OSR_equivalence():
crs1 = CRS.from_string("+proj=longlat +datum=WGS84 +no_defs")
crs2 = CRS.from_string("+proj=latlong +datum=WGS84 +no_defs")
with pytest.warns(FutureWarning):
crs3 = CRS({"init": "EPSG:4326"})
assert crs1 == crs2
# these are not equivalent in proj.4 now as one uses degrees and the other radians
assert crs1 == crs3
def test_crs_OSR_no_equivalence():
crs1 = CRS.from_string("+proj=longlat +datum=WGS84 +no_defs")
crs2 = CRS.from_string("+proj=longlat +datum=NAD27 +no_defs")
assert crs1 != crs2
def test_init_from_wkt():
wgs84 = CRS.from_string("+proj=longlat +datum=WGS84 +no_defs")
from_wkt = CRS(wgs84.to_wkt())
assert wgs84.to_wkt() == from_wkt.to_wkt()
def test_init_from_wkt_invalid():
with pytest.raises(CRSError):
CRS("trash-54322")
with pytest.raises(CRSError):
CRS("")
def test_from_wkt():
wgs84 = CRS.from_string("+proj=longlat +datum=WGS84 +no_defs")
from_wkt = CRS.from_wkt(wgs84.to_wkt())
assert wgs84.to_wkt() == from_wkt.to_wkt()
def test_from_wkt_invalid():
with pytest.raises(CRSError), pytest.warns(UserWarning):
CRS.from_wkt(CRS(4326).to_proj4())
def test_from_user_input_epsg():
with pytest.warns(UserWarning):
assert "+proj=longlat" in CRS.from_user_input("EPSG:4326").to_proj4(4)
def test_from_esri_wkt():
projection_string = (
'PROJCS["USA_Contiguous_Albers_Equal_Area_Conic_USGS_version",'
'GEOGCS["GCS_North_American_1983",DATUM["D_North_American_1983",'
'SPHEROID["GRS_1980",6378137.0,298.257222101]],'
'PRIMEM["Greenwich",0.0],'
'UNIT["Degree",0.0174532925199433]],'
'PROJECTION["Albers"],'
'PARAMETER["false_easting",0.0],'
'PARAMETER["false_northing",0.0],'
'PARAMETER["central_meridian",-96.0],'
'PARAMETER["standard_parallel_1",29.5],'
'PARAMETER["standard_parallel_2",45.5],'
'PARAMETER["latitude_of_origin",23.0],'
'UNIT["Meter",1.0],'
'VERTCS["NAVD_1988",'
'VDATUM["North_American_Vertical_Datum_1988"],'
'PARAMETER["Vertical_Shift",0.0],'
'PARAMETER["Direction",1.0],UNIT["Centimeter",0.01]]]'
)
proj_crs_str = CRS.from_string(projection_string)
proj_crs_wkt = CRS(projection_string)
with pytest.warns(UserWarning):
assert proj_crs_str.to_proj4() == proj_crs_wkt.to_proj4()
assert proj_crs_str.to_proj4(4) == (
"+proj=aea +lat_0=23 +lon_0=-96 +lat_1=29.5 "
"+lat_2=45.5 +x_0=0 +y_0=0 +datum=NAD83 +units=m +no_defs +type=crs"
)
def test_compound_crs():
wkt = """COMPD_CS["unknown",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],UNIT["degree",0.0174532925199433],
AUTHORITY["EPSG","4326"]],VERT_CS["unknown",
VERT_DATUM["unknown",2005],UNIT["metre",1.0,
AUTHORITY["EPSG","9001"]],AXIS["Up",UP]]]"""
assert CRS(wkt).to_wkt("WKT1_GDAL").startswith('COMPD_CS["unknown",GEOGCS["WGS 84"')
def test_ellipsoid():
crs1 = CRS.from_epsg(4326)
assert f"{crs1.ellipsoid.inverse_flattening:.3f}" == "298.257"
assert f"{crs1.ellipsoid.semi_major_metre:.3f}" == "6378137.000"
assert f"{crs1.ellipsoid.semi_minor_metre:.3f}" == "6356752.314"
def test_ellipsoid__semi_minor_not_computed():
cc = CRS("+proj=geos +lon_0=-89.5 +a=6378137.0 +b=6356752.31 h=12345")
assert cc.datum.ellipsoid.semi_minor_metre == 6356752.31
assert cc.datum.ellipsoid.semi_major_metre == 6378137.0
assert not cc.datum.ellipsoid.is_semi_minor_computed
def test_area_of_use():
crs1 = CRS.from_epsg(4326)
assert crs1.area_of_use.bounds == (-180.0, -90.0, 180.0, 90.0)
assert crs1.area_of_use.name == "World."
def test_from_user_input_custom_crs_class():
assert CRS.from_user_input(CustomCRS()) == CRS.from_epsg(4326)
def test_non_crs_error():
with pytest.raises(CRSError, match="Input is not a CRS"):
CRS(
"+proj=pipeline +ellps=GRS80 +step +proj=merc "
"+step +proj=axisswap +order=2,1"
)
def test_sub_crs():
crs = CRS.from_epsg(5972)
sub_crs_list = crs.sub_crs_list
assert len(sub_crs_list) == 2
assert sub_crs_list[0] == CRS.from_epsg(25832)
assert sub_crs_list[1] == CRS.from_epsg(5941)
assert crs.is_projected
assert crs.is_vertical
assert not crs.is_geographic
def test_sub_crs__none():
assert CRS.from_epsg(4326).sub_crs_list == []
def test_coordinate_system():
crs = CRS.from_epsg(26915)
assert repr(crs.coordinate_system).startswith("CS[Cartesian")
assert crs.coordinate_system.name == "cartesian"
assert crs.coordinate_system.name == str(crs.coordinate_system)
assert crs.coordinate_system.axis_list == crs.axis_info
assert len(crs.coordinate_system.axis_list) == 2
def test_coordinate_system_geog():
crs = CRS.from_epsg(4326)
assert repr(crs.coordinate_system).startswith("CS[ellipsoidal")
assert crs.coordinate_system.name == "ellipsoidal"
assert crs.coordinate_system.name == str(crs.coordinate_system)
assert crs.coordinate_system.axis_list == crs.axis_info
assert repr(crs.coordinate_system.axis_list) == (
"[Axis(name=Geodetic latitude, abbrev=Lat, direction=north, "
"unit_auth_code=EPSG, unit_code=9122, unit_name=degree), "
"Axis(name=Geodetic longitude, abbrev=Lon, direction=east, "
"unit_auth_code=EPSG, unit_code=9122, unit_name=degree)]"
)
def test_coordinate_operation():
crs = CRS.from_epsg(26915)
assert repr(crs.coordinate_operation) == (
"\n"
"Name: UTM zone 15N\n"
"Method: Transverse Mercator\n"
"Area of Use:\n"
"- name: Between 96°W and 90°W, northern hemisphere between equator and 84°N, "
"onshore and offshore.\n"
"- bounds: (-96.0, 0.0, -90.0, 84.0)"
)
assert crs.coordinate_operation.method_name == "Transverse Mercator"
assert crs.coordinate_operation.name == str(crs.coordinate_operation)
assert crs.coordinate_operation.method_auth_name == "EPSG"
assert crs.coordinate_operation.method_code == "9807"
assert crs.coordinate_operation.is_instantiable == 1
assert crs.coordinate_operation.has_ballpark_transformation == 0
assert crs.coordinate_operation.accuracy == -1.0
assert repr(crs.coordinate_operation.params) == (
"[Param(name=Latitude of natural origin, auth_name=EPSG, code=8801, "
"value=0.0, unit_name=degree, unit_auth_name=EPSG, "
"unit_code=9102, unit_category=angular), "
"Param(name=Longitude of natural origin, auth_name=EPSG, code=8802, "
"value=-93.0, unit_name=degree, unit_auth_name=EPSG, "
"unit_code=9102, unit_category=angular), "
"Param(name=Scale factor at natural origin, auth_name=EPSG, code=8805, "
"value=0.9996, unit_name=unity, unit_auth_name=EPSG, "
"unit_code=9201, unit_category=scale), "
"Param(name=False easting, auth_name=EPSG, code=8806, value=500000.0, "
"unit_name=metre, unit_auth_name=EPSG, unit_code=9001, unit_category=linear), "
"Param(name=False northing, auth_name=EPSG, code=8807, value=0.0, "
"unit_name=metre, unit_auth_name=EPSG, unit_code=9001, unit_category=linear)]"
)
assert crs.coordinate_operation.grids == []
def test_coordinate_operation_grids():
cc = CoordinateOperation.from_epsg(1312)
if not cc.grids[0].full_name:
assert (
repr(cc.grids)
== "[Grid(short_name=NTv1_0.gsb, full_name=, package_name=, url=, "
"direct_download=False, open_license=False, available=False)]"
)
else:
assert (
repr(cc.grids)
== "[Grid(short_name=NTv1_0.gsb, full_name=NTv1_0.gsb, package_name=, "
"url=, direct_download=False, open_license=False, available=False)]"
)
@pytest.mark.grid
def test_coordinate_operation_grids__alternative_grid_name():
cc = CoordinateOperation.from_epsg(1312, True)
assert len(cc.grids) == 1
grid = cc.grids[0]
assert grid.direct_download is True
assert grid.open_license is True
assert grid.short_name == "ca_nrc_ntv1_can.tif"
assert grid.package_name == ""
assert grid.url == "https://cdn.proj.org/ca_nrc_ntv1_can.tif"
if (PROJ_GTE_91 and grids_available(grid.short_name, check_network=False)) or (
not PROJ_GTE_91 and grids_available(grid.short_name)
):
assert grid.available is True
assert grid.full_name.endswith(grid.short_name)
elif PROJ_GTE_911 and pyproj.network.is_network_enabled():
assert grid.available is True
assert grid.full_name == grid.url
elif PROJ_GTE_91 and pyproj.network.is_network_enabled():
assert grid.available is True
assert grid.full_name == ""
else:
assert grid.available is False
assert grid.full_name == ""
def test_coordinate_operation__missing():
crs = CRS.from_epsg(4326)
assert crs.coordinate_operation is None
def test_coordinate_operation__from_epsg():
cc = CoordinateOperation.from_epsg(16031)
assert cc.method_auth_name == "EPSG"
assert cc.method_code == "9807"
def test_coordinate_operation__from_authority():
cc = CoordinateOperation.from_authority("EPSG", 16031)
assert cc.method_auth_name == "EPSG"
assert cc.method_code == "9807"
@pytest.mark.parametrize(
"user_input",
[
1671,
("EPSG", 1671),
"urn:ogc:def:coordinateOperation:EPSG::1671",
CoordinateOperation.from_epsg(1671),
CoordinateOperation.from_epsg(1671).to_json_dict(),
"RGF93 v1 to WGS 84 (1)",
],
)
def test_coordinate_operation__from_user_input(user_input):
assert CoordinateOperation.from_user_input(
user_input
) == CoordinateOperation.from_epsg(1671)
def test_coordinate_operation__from_user_input__invalid():
with pytest.raises(CRSError, match="Invalid coordinate operation"):
CoordinateOperation.from_user_input({})
def test_coordinate_operation__from_epsg__empty():
with pytest.raises(CRSError, match="Invalid authority"):
CoordinateOperation.from_epsg(1)
def test_coordinate_operation__from_authority__empty():
with pytest.raises(CRSError, match="Invalid authority"):
CoordinateOperation.from_authority("BOB", 4326)
def test_datum__from_epsg():
datum_wkt = (
'ENSEMBLE["World Geodetic System 1984 ensemble",'
'MEMBER["World Geodetic System 1984 (Transit)",ID["EPSG",1166]],'
'MEMBER["World Geodetic System 1984 (G730)",ID["EPSG",1152]],'
'MEMBER["World Geodetic System 1984 (G873)",ID["EPSG",1153]],'
'MEMBER["World Geodetic System 1984 (G1150)",ID["EPSG",1154]],'
'MEMBER["World Geodetic System 1984 (G1674)",ID["EPSG",1155]],'
'MEMBER["World Geodetic System 1984 (G1762)",ID["EPSG",1156]],'
'MEMBER["World Geodetic System 1984 (G2139)",ID["EPSG",1309]],'
'ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1],'
'ID["EPSG",7030]],ENSEMBLEACCURACY[2.0],ID["EPSG",6326]]'
)
assert Datum.from_epsg("6326").to_wkt() == datum_wkt
def test_datum__from_authority():
dt = Datum.from_authority("EPSG", 6326)
assert dt.name == "World Geodetic System 1984 ensemble"
def test_datum__from_epsg__invalid():
with pytest.raises(CRSError, match="Invalid authority"):
Datum.from_epsg(1)
def test_datum__from_authority__invalid():
with pytest.raises(CRSError, match="Invalid authority"):
Datum.from_authority("BOB", 1)
@pytest.mark.parametrize(
"user_input",
[
6326,
("EPSG", 6326),
"urn:ogc:def:ensemble:EPSG::6326",
Datum.from_epsg(6326),
Datum.from_epsg(6326).to_json_dict(),
"World Geodetic System 1984",
],
)
def test_datum__from_user_input(user_input):
assert Datum.from_user_input(user_input) == Datum.from_epsg(6326)
def test_datum__from_user_input__invalid():
with pytest.raises(CRSError, match="Invalid datum"):
Datum.from_user_input({})
def test_prime_meridian__from_epsg():
assert PrimeMeridian.from_epsg(8903).to_wkt() == (
'PRIMEM["Paris",2.5969213,ANGLEUNIT["grad",0.0157079632679489],ID["EPSG",8903]]'
)
def test_prime_meridian__from_authority():
assert PrimeMeridian.from_authority("EPSG", 8903).name == "Paris"
def test_prime_meridian__from_epsg__invalid():
with pytest.raises(CRSError, match="Invalid authority"):
PrimeMeridian.from_epsg(1)
def test_prime_meridian__from_authority__invalid():
with pytest.raises(CRSError, match="Invalid authority"):
PrimeMeridian.from_authority("Bob", 1)
@pytest.mark.parametrize(
"user_input",
[
8901,
("EPSG", 8901),
"urn:ogc:def:meridian:EPSG::8901",
PrimeMeridian.from_epsg(8901),
PrimeMeridian.from_epsg(8901).to_json_dict(),
"Greenwich",
],
)
def test_prime_meridian__from_user_input(user_input):
assert PrimeMeridian.from_user_input(user_input) == PrimeMeridian.from_epsg(8901)
def test_prime_meridian__from_user_input__invalid():
with pytest.raises(CRSError, match="Invalid prime meridian"):
PrimeMeridian.from_user_input({})
def test_ellipsoid__from_epsg():
assert Ellipsoid.from_epsg(7030).to_wkt() == (
'ELLIPSOID["WGS 84",6378137,298.257223563,'
'LENGTHUNIT["metre",1],ID["EPSG",7030]]'
)
def test_ellipsoid__from_authority():
assert Ellipsoid.from_authority("EPSG", 7030).name == "WGS 84"
def test_ellipsoid__from_epsg__invalid():
with pytest.raises(CRSError, match="Invalid authority"):
Ellipsoid.from_epsg(1)
def test_ellipsoid__from_authority__invalid():
with pytest.raises(CRSError, match="Invalid authority"):
Ellipsoid.from_authority("BOB", 1)
@pytest.mark.parametrize(
"user_input",
[
7001,
("EPSG", 7001),
"urn:ogc:def:ellipsoid:EPSG::7001",
Ellipsoid.from_epsg(7001),
Ellipsoid.from_epsg(7001).to_json_dict(),
"Airy 1830",
],
)
def test_ellipsoid__from_user_input(user_input):
assert Ellipsoid.from_user_input(user_input) == Ellipsoid.from_epsg(7001)
def test_ellipsoid__from_user_input__invalid():
with pytest.raises(CRSError, match="Invalid ellipsoid"):
Ellipsoid.from_user_input({})
CS_JSON_DICT = {
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "CoordinateSystem",
"subtype": "Cartesian",
"axis": [
{"name": "Easting", "abbreviation": "E", "direction": "east", "unit": "metre"},
{
"name": "Northing",
"abbreviation": "N",
"direction": "north",
"unit": "metre",
},
],
}
@pytest.mark.parametrize(
"user_input",
[
CS_JSON_DICT,
json.dumps(CS_JSON_DICT),
CoordinateSystem.from_json_dict(CS_JSON_DICT),
],
)
def test_coordinate_system__from_user_input(user_input):
assert CoordinateSystem.from_user_input(
user_input
) == CoordinateSystem.from_json_dict(CS_JSON_DICT)
@pytest.mark.parametrize(
"user_input",
[
7001,
("EPSG", 7001),
"urn:ogc:def:ellipsoid:EPSG::7001",
Ellipsoid.from_epsg(7001),
Ellipsoid.from_epsg(7001).to_json_dict(),
],
)
def test_coordinate_system__from_user_input__invalid(user_input):
with pytest.raises(CRSError, match="Invalid"):
CoordinateSystem.from_user_input(user_input)
def test_bound_crs_is_geographic():
assert CRS(
"proj=longlat datum=WGS84 no_defs ellps=WGS84 towgs84=0,0,0"
).is_geographic
def test_coordinate_operation_towgs84_three():
crs = CRS("+proj=latlong +ellps=GRS80 +towgs84=-199.87,74.79,246.62")
assert crs.coordinate_operation.towgs84 == [-199.87, 74.79, 246.62]
def test_coordinate_operation_towgs84_seven():
crs = CRS(
"+proj=tmerc +lat_0=0 +lon_0=15 +k=0.9996 +x_0=2520000 +y_0=0 "
"+ellps=intl +towgs84=-122.74,-34.27,-22.83,-1.884,-3.400,-3.030,-15.62"
)
assert crs.coordinate_operation.towgs84 == [
-122.74,
-34.27,
-22.83,
-1.884,
-3.4,
-3.03,
-15.62,
]
def test_axis_info_bound():
crs = CRS(
"+proj=tmerc +lat_0=0 +lon_0=15 +k=0.9996 +x_0=2520000 +y_0=0 "
"+ellps=intl +towgs84=-122.74,-34.27,-22.83,-1.884,-3.400,-3.030,-15.62"
)
assert [axis.direction for axis in crs.axis_info] == ["east", "north"]
def test_coordinate_operation_towgs84_missing():
crs = CRS("epsg:3004")
assert crs.coordinate_operation.towgs84 == []
@pytest.mark.parametrize(
"wkt_version_str, wkt_version_enum",
[
("WKT1_GDAL", WktVersion.WKT1_GDAL),
("WKT2_2018", WktVersion.WKT2_2018),
("WKT2_2018_SIMPLIFIED", WktVersion.WKT2_2018_SIMPLIFIED),
("WKT2_2019", WktVersion.WKT2_2019),
("WKT2_2019_SIMPLIFIED", WktVersion.WKT2_2019_SIMPLIFIED),
("WKT2_2015", WktVersion.WKT2_2015),
("WKT2_2015_SIMPLIFIED", WktVersion.WKT2_2015_SIMPLIFIED),
],
)
def test_to_wkt_enum(wkt_version_str, wkt_version_enum):
crs = CRS.from_epsg(4326)
assert crs.to_wkt(wkt_version_str) == crs.to_wkt(wkt_version_enum)
def test_to_wkt_enum__invalid():
crs = CRS.from_epsg(4326)
with pytest.raises(ValueError, match="Invalid value"):
crs.to_wkt("WKT_INVALID")
@pytest.mark.parametrize(
"wkt_version",
["WKT2_2015", "WKT2_2015_SIMPLIFIED", "WKT1_GDAL", "WKT1_ESRI"],
)
def test_to_wkt_none_warning(wkt_version):
wkt_string = (
'PROJCRS["unknown",BASEGEOGCRS["unknown",DATUM["unknown",'
'ELLIPSOID["WGS 84",6378137,298.257223563,LENGTHUNIT["metre",1,'
'ID["EPSG",9001]]]],PRIMEM["Greenwich",0,ANGLEUNIT["degree",0.0174532925199],'
'ID["EPSG",8901]]],CONVERSION["unknown",METHOD["Equidistant Cylindrical",'
'ID["EPSG",1028]],PARAMETER["Latitude of 1st standard parallel",0,'
'ANGLEUNIT["degree",0.0174532925199433],ID["EPSG",8823]],'
'PARAMETER["Longitude of natural origin",0,ANGLEUNIT["degree",0.0174532925199],'
'ID["EPSG",8802]],PARAMETER["False easting",0,'
'LENGTHUNIT["unknown",111319.490793274],ID["EPSG",8806]],'
'PARAMETER["False northing",0,LENGTHUNIT["unknown",111319.490793274],'
'ID["EPSG",8807]]],CS[Cartesian,3],AXIS["(E)",east,ORDER[1],'
'LENGTHUNIT["unknown",111319.490793274]],AXIS["(N)",north,ORDER[2],'
'LENGTHUNIT["unknown",111319.490793274]],AXIS["ellipsoidal height (h)",up,'
'ORDER[3],LENGTHUNIT["metre",1,ID["EPSG",9001]]]]'
)
crs = CRS.from_wkt(wkt_string)
with pytest.raises(CRSError, match="CRS cannot be converted to a WKT string"):
assert crs.to_wkt(version=wkt_version) is None
def test_to_proj4_none_warning():
crs = CRS("EPSG:4326")
with patch("pyproj.crs.crs.CRS._crs") as crs_mock, pytest.raises(
CRSError, match="CRS cannot be converted to a PROJ string"
):
crs_mock.to_proj4.return_value = None
assert crs.to_proj4() is None
def test_to_json_none_warning():
crs = CRS("EPSG:4326")
with patch("pyproj.crs.crs.CRS._crs") as crs_mock, pytest.raises(
CRSError, match="CRS cannot be converted to a PROJ JSON string"
):
crs_mock.to_json.return_value = None
assert crs.to_json() is None
def test_to_proj4_enum():
crs = CRS.from_epsg(4326)
with pytest.warns(UserWarning):
assert crs.to_proj4(4) == crs.to_proj4(ProjVersion.PROJ_4)
assert crs.to_proj4(5) == crs.to_proj4(ProjVersion.PROJ_5)
def test_datum_equals():
datum = Datum.from_epsg(6326)
assert datum == 6326
assert not datum != 6326
assert datum != "invalid"
@pytest.mark.parametrize(
"input_str",
[
"urn:ogc:def:ensemble:EPSG::6326",
"World Geodetic System 1984",
],
)
def test_datum__from_string(input_str):
dd = Datum.from_string(input_str)
assert dd.name == "World Geodetic System 1984 ensemble"
assert dd.type_name == "Datum Ensemble"
@pytest.mark.parametrize(
"input_str, type_name",
[
('ENGINEERINGDATUM["Engineering datum"]', "Engineering Datum"),
('PDATUM["Mean Sea Level",ANCHOR["1013.25 hPa at 15°C"]]', "Parametric Datum"),
(
'TDATUM["Gregorian calendar",CALENDAR["proleptic Gregorian"],'
"TIMEORIGIN[0000-01-01]]",
"Temporal Datum",
),
],
)
def test_datum__from_string__type_name(input_str, type_name):
dd = Datum.from_string(input_str)
assert dd.type_name == type_name
@pytest.mark.parametrize(
"input_name", ["World Geodetic System 1984", "WGS84", "WGS 84"]
)
def test_datum__from_name(input_name):
dd = Datum.from_name(input_name)
assert dd.name == "World Geodetic System 1984 ensemble"
@pytest.mark.parametrize("auth_name", [None, "ESRI"])
def test_datum_from_name__auth_type(auth_name):
dd = Datum.from_name(
"WGS_1984_Geoid",
auth_name=auth_name,
datum_type=DatumType.VERTICAL_REFERENCE_FRAME,
)
assert dd.name == "WGS_1984_Geoid"
assert dd.type_name == "Vertical Reference Frame"
def test_datum_from_name__any_type():
dd = Datum.from_name("WGS_1984_Geoid")
assert dd.name == "WGS_1984_Geoid"
assert dd.type_name == "Vertical Reference Frame"
@pytest.mark.parametrize(
"invalid_str", ["3-598y5-98y", "urn:ogc:def:ellipsoid:EPSG::7001"]
)
def test_datum__from_name__invalid(invalid_str):
with pytest.raises(CRSError, match="Invalid datum name:"):
Datum.from_name(invalid_str)
def test_datum__from_name__invalid_type():
with pytest.raises(CRSError, match="Invalid datum name: WGS84"):
Datum.from_name("WGS84", datum_type="VERTICAL_REFERENCE_FRAME")
@pytest.mark.parametrize(
"invalid_str", ["3-598y5-98y", "urn:ogc:def:ellipsoid:EPSG::7001"]
)
def test_datum__from_string__invalid(invalid_str):
with pytest.raises(CRSError, match="Invalid datum string"):
Datum.from_string(invalid_str)
def test_ellipsoid_equals():
ellipsoid = Ellipsoid.from_epsg(7001)
assert ellipsoid == 7001
assert not ellipsoid != 7001
assert ellipsoid != "invalid"
@pytest.mark.parametrize("input_str", ["urn:ogc:def:ellipsoid:EPSG::7001", "Airy 1830"])
def test_ellipsoid__from_string(input_str):
ee = Ellipsoid.from_string(input_str)
assert ee.name == "Airy 1830"
@pytest.mark.parametrize(
"input_str,long_name",
[
("Airy 1830", "Airy 1830"),
("intl", "International 1924 (Hayford 1909, 1910)"),
(
"International 1924 (Hayford 1909, 1910)",
"International 1924 (Hayford 1909, 1910)",
),
],
)
def test_ellipsoid__from_name(input_str, long_name):
ee = Ellipsoid.from_name(input_str)
assert ee.name == long_name
@pytest.mark.parametrize("invalid_str", ["3-598y5-98y", "urn:ogc:def:datum:EPSG::6326"])
def test_ellipsoid__from_name__invalid(invalid_str):
with pytest.raises(CRSError, match="Invalid ellipsoid name"):
Ellipsoid.from_name(invalid_str)
def test_ellipsoid__from_name__invalid__auth():
with pytest.raises(CRSError, match="Invalid ellipsoid name"):
Ellipsoid.from_name("intl", auth_name="ESRI")
@pytest.mark.parametrize("invalid_str", ["3-598y5-98y", "urn:ogc:def:datum:EPSG::6326"])
def test_ellipsoid__from_string__invalid(invalid_str):
with pytest.raises(CRSError, match="Invalid ellipsoid string"):
Ellipsoid.from_string(invalid_str)
def test_prime_meridian_equals():
pm = PrimeMeridian.from_epsg(8901)
assert pm == 8901
assert not pm != 8901
assert pm != "invalid"
@pytest.mark.parametrize("input_str", ["urn:ogc:def:meridian:EPSG::8901", "Greenwich"])
def test_prime_meridian__from_string(input_str):
pm = PrimeMeridian.from_string(input_str)
assert pm.name == "Greenwich"
@pytest.mark.parametrize("invalid_str", ["3-598y5-98y", "urn:ogc:def:datum:EPSG::6326"])
def test_prime_meridian__from_string__invalid(invalid_str):
with pytest.raises(CRSError, match="Invalid prime meridian string"):
PrimeMeridian.from_string(invalid_str)
def test_prime_meridian__from_name():
pm = PrimeMeridian.from_name("Greenwich")
assert pm.name == "Greenwich"
@pytest.mark.parametrize("invalid_str", ["3-598y5-98y", "urn:ogc:def:datum:EPSG::6326"])
def test_prime_meridian__from_name__invalid(invalid_str):
with pytest.raises(CRSError, match="Invalid prime meridian name"):
PrimeMeridian.from_name(invalid_str)
def test_coordinate_operation_equals():
co = CoordinateOperation.from_epsg(1671)
assert co == 1671
assert not co != 1671
assert co != "invalid"
@pytest.mark.parametrize(
"input_str",
["urn:ogc:def:coordinateOperation:EPSG::1671", "RGF93 v1 to WGS 84 (1)"],
)
def test_coordinate_operation__from_string(input_str):
co = CoordinateOperation.from_string(input_str)
assert co.name == "RGF93 v1 to WGS 84 (1)"
def test_coordinate_operation__from_name():
co = CoordinateOperation.from_name("UTM zone 12N")
assert co.name == "UTM zone 12N"
def test_coordinate_operation__from_name_auth_type():
co = CoordinateOperation.from_name(
"ITRF_2000_To_WGS_1984",
auth_name="ESRI",
coordinate_operation_type=CoordinateOperationType.TRANSFORMATION,
)
assert co.name == "ITRF_2000_To_WGS_1984"
@pytest.mark.parametrize("invalid_str", ["3-598y5-98y", "urn:ogc:def:datum:EPSG::6326"])
def test_coordinate_operation__from_name__invalid(invalid_str):
with pytest.raises(CRSError, match="Invalid coordinate operation name"):
CoordinateOperation.from_name(invalid_str)
@pytest.mark.parametrize("invalid_str", ["3-598y5-98y", "urn:ogc:def:datum:EPSG::6326"])
def test_coordinate_operation__from_string__invalid(invalid_str):
with pytest.raises(CRSError, match="Invalid coordinate operation string"):
CoordinateOperation.from_string(invalid_str)
_COORDINATE_SYSTEM_STR = (
'{"$schema":"https://proj.org/schemas/v0.2/projjson.schema.json",'
'"type":"CoordinateSystem","subtype":"ellipsoidal",'
'"axis":[{"name":"Geodetic latitude","abbreviation":"Lat",'
'"direction":"north","unit":"degree"},'
'{"name":"Geodetic longitude","abbreviation":"Lon",'
'"direction":"east","unit":"degree"}],'
'"id":{"authority":"EPSG","code":6422}}'
)
def test_coordinate_system__equals():
cs = CoordinateSystem.from_string(_COORDINATE_SYSTEM_STR)
assert cs == _COORDINATE_SYSTEM_STR
assert not cs != _COORDINATE_SYSTEM_STR
assert cs != "invalid"
def test_coordinate_system__from_string():
cs = CoordinateSystem.from_string(_COORDINATE_SYSTEM_STR)
assert cs.name == "ellipsoidal"
@pytest.mark.parametrize(
"invalid_cs_string", ["3-598y5-98y", "urn:ogc:def:datum:EPSG::6326"]
)
def test_coordinate_system__from_string__invalid(invalid_cs_string):
with pytest.raises(CRSError, match="Invalid coordinate system string"):
CoordinateSystem.from_string(invalid_cs_string)
def test_to_proj4_enum__invalid():
crs = CRS.from_epsg(4326)
with pytest.raises(ValueError, match="Invalid value"), pytest.warns(UserWarning):
crs.to_proj4(1)
def test_geodetic_crs():
cc = CRS("epsg:3004")
assert cc.geodetic_crs.to_epsg() == 4265
def test_itrf_init():
crs = CRS("ITRF2000")
assert crs.name == "ITRF2000"
def test_compound_crs_init():
crs = CRS("EPSG:2393+5717")
assert crs.name == "KKJ / Finland Uniform Coordinate System + N60 height"
def test_compound_crs_urn_init():
crs = CRS("urn:ogc:def:crs,crs:EPSG::2393,crs:EPSG::5717")
assert crs.name == "KKJ / Finland Uniform Coordinate System + N60 height"
def test_from_authority__ignf():
cc = CRS.from_authority("IGNF", "ETRS89UTM28")
assert cc.to_authority() == ("IGNF", "ETRS89UTM28")
assert cc.to_authority("EPSG") == ("EPSG", "25828")
assert cc.to_epsg() == 25828
def test_ignf_authority_repr():
assert repr(CRS.from_authority("IGNF", "ETRS89UTM28")).startswith(
""
)
def test_crs_hash():
"""hashes of equivalent CRS are equal"""
assert hash(CRS.from_epsg(3857)) == hash(CRS.from_epsg(3857))
def test_crs_hash_unequal():
"""hashes of non-equivalent CRS are not equal"""
assert hash(CRS.from_epsg(3857)) != hash(CRS.from_epsg(4326))
def test_crs_init_user_input():
assert CRS(("IGNF", "ETRS89UTM28")).to_authority() == ("IGNF", "ETRS89UTM28")
assert CRS(4326).to_epsg() == 4326
proj4_dict = {"proj": "longlat", "datum": "WGS84", "no_defs": None, "type": "crs"}
with pytest.warns(UserWarning):
assert CRS({"proj": "lonlat", "datum": "WGS84"}).to_dict() == proj4_dict
assert CRS(proj="lonlat", datum="WGS84").to_dict() == proj4_dict
assert (
CRS('{"proj": "longlat", "ellps": "WGS84", "datum": "WGS84"}').to_dict()
== proj4_dict
)
assert CRS(CRS(4326)).is_exact_same(CRS(CustomCRS()))
def test_crs_is_exact_same__non_crs_input():
assert CRS(4326).is_exact_same("epsg:4326")
with pytest.warns(FutureWarning):
assert not CRS(4326).is_exact_same("+init=epsg:4326")
def test_derived_projected_crs():
wkt = (
'DERIVEDPROJCRS["derived projectedCRS",\n'
' BASEPROJCRS["WGS 84 / UTM zone 31N",\n'
' BASEGEOGCRS["WGS 84",\n'
' DATUM["World Geodetic System 1984",\n'
' ELLIPSOID["WGS 84",6378137,298.257223563,\n'
' LENGTHUNIT["metre",1]]],\n'
' PRIMEM["Greenwich",0,\n'
' ANGLEUNIT["degree",0.0174532925199433]]],\n'
' CONVERSION["UTM zone 31N",\n'
' METHOD["Transverse Mercator",\n'
' ID["EPSG",9807]],\n'
' PARAMETER["Latitude of natural origin",0,\n'
' ANGLEUNIT["degree",0.0174532925199433],\n'
' ID["EPSG",8801]],\n'
' PARAMETER["Longitude of natural origin",3,\n'
' ANGLEUNIT["degree",0.0174532925199433],\n'
' ID["EPSG",8802]],\n'
' PARAMETER["Scale factor at natural origin",0.9996,\n'
' SCALEUNIT["unity",1],\n'
' ID["EPSG",8805]],\n'
' PARAMETER["False easting",500000,\n'
' LENGTHUNIT["metre",1],\n'
' ID["EPSG",8806]],\n'
' PARAMETER["False northing",0,\n'
' LENGTHUNIT["metre",1],\n'
' ID["EPSG",8807]]]],\n'
' DERIVINGCONVERSION["unnamed",\n'
' METHOD["PROJ unimplemented"],\n'
' PARAMETER["foo",1.0,UNIT["metre",1]]],\n'
" CS[Cartesian,2],\n"
' AXIS["(E)",east,\n'
" ORDER[1],\n"
' LENGTHUNIT["metre",1,\n'
' ID["EPSG",9001]]],\n'
' AXIS["(N)",north,\n'
" ORDER[2],\n"
' LENGTHUNIT["metre",1,\n'
' ID["EPSG",9001]]]]'
)
crs = CRS(wkt)
assert crs.is_derived
assert crs.type_name == "Derived Projected CRS"
def test_to_string__no_auth():
proj = CRS("+proj=latlong +ellps=GRS80 +towgs84=-199.87,74.79,246.62")
assert (
proj.to_string()
== "+proj=latlong +ellps=GRS80 +towgs84=-199.87,74.79,246.62 +type=crs"
)
def test_to_string__auth():
assert CRS(("IGNF", "ETRS89UTM28")).to_string() == "IGNF:ETRS89UTM28"
def test_srs__no_plus():
assert (
CRS("proj=longlat datum=WGS84 no_defs").srs
== "proj=longlat datum=WGS84 no_defs type=crs"
)
def test_equals_different_type():
assert CRS("epsg:4326") != ""
assert not CRS("epsg:4326") == ""
assert CRS("epsg:4326") != 27700
assert not CRS("epsg:4326") == 27700
assert not CRS("epsg:4326") != 4326
assert CRS("epsg:4326") == 4326
def test_is_exact_same_different_type():
assert not CRS("epsg:4326").is_exact_same(None)
def test_compare_crs_non_crs():
assert CRS.from_epsg(4326) != 4.2
assert CRS.from_epsg(4326) == 4326
with pytest.warns(FutureWarning):
assert CRS.from_dict({"init": "epsg:4326"}) == {"init": "epsg:4326"}
assert CRS.from_dict({"init": "epsg:4326"}) != "epsg:4326"
assert CRS("epsg:4326") == CustomCRS()
def test_is_geocentric__bound():
with pytest.warns(FutureWarning):
ccs = CRS("+init=epsg:4328 +towgs84=0,0,0")
assert ccs.is_geocentric
def test_is_geocentric():
ccs = CRS.from_epsg(4328)
assert ccs.is_geocentric
def test_is_vertical():
cc = CRS.from_epsg(5717)
assert cc.is_vertical
def test_is_engineering():
eng_wkt = (
'ENGCRS["A construction site CRS",\n'
'EDATUM["P1",ANCHOR["Peg in south corner"]],\n'
'CS[Cartesian,2],\nAXIS["site east",southWest,ORDER[1]],\n'
'AXIS["site north",southEast,ORDER[2]],\n'
'LENGTHUNIT["metre",1.0],\n'
'TIMEEXTENT["date/time t1","date/time t2"]]'
)
assert CRS(eng_wkt).is_engineering
def test_source_crs__bound():
with pytest.warns(FutureWarning):
assert CRS("+init=epsg:4328 +towgs84=0,0,0").source_crs.name == "unknown"
def test_source_crs__missing():
assert CRS("epsg:4326").source_crs is None
def test_target_crs__bound():
with pytest.warns(FutureWarning):
assert CRS("+init=epsg:4328 +towgs84=0,0,0").target_crs.name == "WGS 84"
def test_target_crs__missing():
assert CRS("epsg:4326").target_crs is None
def test_whitepace_between_equals():
crs = CRS(
"+proj =lcc +lat_1= 30.0 +lat_2= 35.0 +lat_0=30.0 +lon_0=87.0 +x_0=0 +y_0=0"
)
assert crs.srs == (
"+proj=lcc +lat_1=30.0 +lat_2=35.0 +lat_0=30.0 "
"+lon_0=87.0 +x_0=0 +y_0=0 +type=crs"
)
def test_to_dict_no_proj4():
crs = CRS(
{
"a": 6371229.0,
"b": 6371229.0,
"lon_0": -10.0,
"o_lat_p": 30.0,
"o_lon_p": 0.0,
"o_proj": "longlat",
"proj": "ob_tran",
}
)
with pytest.warns(UserWarning):
assert crs.to_dict() == {
"R": 6371229,
"lon_0": -10,
"no_defs": None,
"o_lat_p": 30,
"o_lon_p": 0,
"o_proj": "longlat",
"proj": "ob_tran",
"type": "crs",
}
def test_to_dict_from_dict():
cc = CRS.from_epsg(4326)
with pytest.warns(UserWarning):
assert CRS.from_dict(cc.to_dict()).name == "unknown"
def test_from_dict__invalid():
with pytest.raises(CRSError, match="CRS input is not a dict"):
CRS.from_dict(4326)
@pytest.mark.parametrize(
"class_type",
[Datum, Ellipsoid, PrimeMeridian, CoordinateOperation, CoordinateSystem],
)
def test_incorrectly_initialized(class_type):
with pytest.raises(RuntimeError):
class_type()
def test_scope__remarks():
co = CoordinateOperation.from_epsg("8048")
assert "GDA94" in co.scope
assert "Scale difference" in co.remarks
def test_crs__scope__remarks__missing():
cc = CRS("+proj=latlon")
assert cc.scope is None
assert cc.remarks is None
def test_operations_missing():
cc = CRS(("IGNF", "ETRS89UTM28"))
assert cc.coordinate_operation.operations == ()
def test_operations():
transformer = TransformerGroup(28356, 7856).transformers[0]
coord_op = CoordinateOperation.from_string(transformer.to_wkt())
assert coord_op.operations == transformer.operations
def test_operations__scope_remarks():
operation = TransformerGroup(28356, 7856).transformers[0].operations[1]
coord_op = CoordinateOperation.from_string(operation.to_wkt())
assert coord_op == operation
assert coord_op.remarks == operation.remarks
assert coord_op.scope == operation.scope
def test_crs_equals():
assert CRS(4326).equals("epsg:4326")
def test_crs_equals__ignore_axis_order():
with pytest.warns(FutureWarning):
assert CRS("epsg:4326").equals("+init=epsg:4326", ignore_axis_order=True)
@pytest.mark.parametrize(
"crs_input",
[
"+proj=utm +zone=15",
26915,
"+proj=utm +zone=15 +towgs84=0,0,0",
"EPSG:26915+5717",
],
)
def test_utm_zone(crs_input):
assert CRS(crs_input).utm_zone == "15N"
@pytest.mark.parametrize("crs_input", ["+proj=tmerc", "epsg:4326"])
def test_utm_zone__none(crs_input):
assert CRS(crs_input).utm_zone is None
def test_numpy_bool_kwarg_false():
# Issue 564
south = numpy.array(50) < 0
crs = CRS(
proj="utm", zone=32, ellipsis="WGS84", datum="WGS84", units="m", south=south
)
assert "south" not in crs.srs
def test_numpy_bool_kwarg_true():
# Issue 564
south = numpy.array(50) > 0
crs = CRS(
proj="utm", zone=32, ellipsis="WGS84", datum="WGS84", units="m", south=south
)
assert "+south " in crs.srs
@pytest.mark.skipif(
pyproj._datadir._USE_GLOBAL_CONTEXT, reason="Global Context not Threadsafe."
)
def test_crs_multithread():
# https://github.com/pyproj4/pyproj/issues/782
crs = CRS(4326)
def to_wkt(num):
return crs.to_wkt()
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
for result in executor.map(to_wkt, range(10)):
pass
@pytest.mark.skipif(
platform.python_implementation() != "CPython", reason="pypy process unstable."
)
def test_crs_multiprocess():
# https://github.com/pyproj4/pyproj/issues/933
with concurrent.futures.ProcessPoolExecutor(max_workers=2) as executor:
for result in executor.map(CRS, [4326 for _ in range(10)]):
pass
def test_coordinate_operation__to_proj4():
operation = CoordinateOperation.from_string(
"+proj=pipeline +step +proj=axisswap +order=2,1 +step "
"+proj=unitconvert +xy_in=deg +xy_out=rad +step "
"+proj=webmerc +lat_0=0 +lon_0=0 +x_0=0 +y_0=0 +ellps=WGS84"
)
proj_string = operation.to_proj4()
assert "+proj=pipeline" in proj_string
assert "\n" not in proj_string
def test_coordinate_operation__to_proj4__pretty():
operation = CoordinateOperation.from_string(
"+proj=pipeline +step +proj=axisswap +order=2,1 +step "
"+proj=unitconvert +xy_in=deg +xy_out=rad +step "
"+proj=webmerc +lat_0=0 +lon_0=0 +x_0=0 +y_0=0 +ellps=WGS84"
)
proj_string = operation.to_proj4(pretty=True)
assert "+proj=pipeline" in proj_string
assert "\n" in proj_string
@pytest.mark.parametrize(
"crs_input",
[
"EPSG:4326",
"EPSG:2056",
],
)
def test_to_3d(crs_input):
crs = CRS(crs_input)
assert len(crs.axis_info) == 2
crs_3d = crs.to_3d()
assert len(crs_3d.axis_info) == 3
vert_axis = crs_3d.axis_info[-1]
assert vert_axis.name == "Ellipsoidal height"
assert vert_axis.unit_name == "metre"
assert vert_axis.direction == "up"
assert crs_3d.to_3d() == crs_3d
assert crs_3d.name == crs.name
def test_to_3d__name():
crs_3d = CRS("EPSG:2056").to_3d(name="TEST")
assert crs_3d.name == "TEST"
@pytest.mark.parametrize(
"crs_input",
[
CRS("EPSG:4979"), # native 3D
CRS("EPSG:2056").to_3d(), # a 2D CRS converted to 3D
CRS("EPSG:4326+5773"), # a 3D CRS based on a compound
],
)
def test_to_2d(crs_input):
assert len(crs_input.axis_info) == 3
horizon_axis_crs_3d = crs_input.axis_info[:-1]
crs_2d = crs_input.to_2d()
horizon_axis_crs_2d = crs_input.axis_info
assert len(crs_2d.axis_info) == 2
assert horizon_axis_crs_2d[0] == horizon_axis_crs_3d[0]
assert horizon_axis_crs_2d[1] == horizon_axis_crs_3d[1]
assert crs_2d.to_2d() == crs_2d
# For CompoundCRS, the 3D name is initialized different from 2D
if crs_input.name == "WGS 84 + EGM96 height":
assert crs_2d.name == "WGS 84"
# Otherwise, no change
else:
assert crs_2d.name == crs_input.name
def test_to_2d__name():
crs_2d = CRS("EPSG:2056").to_3d().to_2d(name="TEST")
assert crs_2d.name == "TEST"
def test_crs__pickle(tmp_path):
assert_can_pickle(CRS("epsg:4326"), tmp_path)
def test_is_derived():
assert CRS(
"+proj=ob_tran +o_proj=longlat +o_lat_p=0 +o_lon_p=0 +lon_0=0"
).is_derived
assert not CRS("+proj=latlon").is_derived
def test_inheritance__from_methods():
class ChildCRS(CRS):
def new_method(self):
return 1
def assert_inheritance_valid(new_crs):
assert new_crs.new_method() == 1
assert isinstance(new_crs, ChildCRS)
assert isinstance(new_crs.geodetic_crs, ChildCRS)
assert isinstance(new_crs.source_crs, (type(None), ChildCRS))
assert isinstance(new_crs.target_crs, (type(None), ChildCRS))
assert isinstance(new_crs.to_3d(), ChildCRS)
for sub_crs in new_crs.sub_crs_list:
assert isinstance(sub_crs, ChildCRS)
assert_inheritance_valid(ChildCRS.from_epsg(4326))
assert_inheritance_valid(ChildCRS.from_string("EPSG:2056"))
with pytest.warns(FutureWarning):
assert_inheritance_valid(ChildCRS.from_proj4("+init=epsg:4328 +towgs84=0,0,0"))
assert_inheritance_valid(ChildCRS.from_user_input("EPSG:4326+5773"))
assert_inheritance_valid(ChildCRS.from_json(CRS(4326).to_json()))
assert_inheritance_valid(ChildCRS.from_json_dict(CRS(4326).to_json_dict()))
assert_inheritance_valid(ChildCRS.from_wkt(CRS(4326).to_wkt()))
def test_list_authority():
assert CRS("+proj=utm +zone=15").list_authority() == [
AuthorityMatchInfo(auth_name="EPSG", code="32615", confidence=70)
]
def test_list_authority__multiple():
auth_list = CRS("+proj=longlat").list_authority()
assert AuthorityMatchInfo(auth_name="OGC", code="CRS84", confidence=70) in auth_list
assert AuthorityMatchInfo(auth_name="EPSG", code="4326", confidence=70) in auth_list
pyproj-3.6.1/test/crs/test_crs_cf.py 0000664 0000000 0000000 00000207057 14502715416 0017502 0 ustar 00root root 0000000 0000000 import numpy
import pytest
from numpy.testing import assert_almost_equal
from packaging import version
from pyproj import CRS
from pyproj.crs import ProjectedCRS
from pyproj.crs._cf1x8 import _try_list_if_string
from pyproj.crs.coordinate_operation import (
LambertAzimuthalEqualAreaConversion,
LambertCylindricalEqualAreaConversion,
MercatorAConversion,
OrthographicConversion,
PolarStereographicAConversion,
PolarStereographicBConversion,
SinusoidalConversion,
StereographicConversion,
VerticalPerspectiveConversion,
)
from pyproj.exceptions import CRSError
from test.conftest import PROJ_GTE_901, PROJ_LOOSE_VERSION
def _to_dict(operation):
param_dict = {}
for param in operation.params:
param_dict[param.name] = param.value
return param_dict
def _test_roundtrip(expected_cf, wkt_startswith):
crs = CRS.from_cf(expected_cf)
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith(wkt_startswith)
assert_almost_equal(
cf_dict.pop("semi_minor_axis"), expected_cf.pop("semi_minor_axis")
)
assert_almost_equal(
cf_dict.pop("inverse_flattening"), expected_cf.pop("inverse_flattening")
)
if "towgs84" in expected_cf:
assert_almost_equal(cf_dict.pop("towgs84"), expected_cf.pop("towgs84"))
assert cf_dict == expected_cf
def test_cf_from_numpy_dtypes():
cf = {
"grid_mapping_name": "lambert_conformal_conic",
"standard_parallel": numpy.array([60, 30], dtype="f4"),
"longitude_of_central_meridian": numpy.float32(0),
"latitude_of_projection_origin": numpy.int32(45),
}
crs = CRS.from_cf(cf)
with pytest.warns(UserWarning):
assert crs.to_dict() == {
"datum": "WGS84",
"lat_0": 45,
"lat_1": 60,
"lat_2": 30,
"lon_0": 0,
"no_defs": None,
"proj": "lcc",
"type": "crs",
"units": "m",
"x_0": 0,
"y_0": 0,
}
def test_to_cf_transverse_mercator():
crs = CRS(
proj="tmerc",
lat_0=0,
lon_0=15,
k=0.9996,
x_0=2520000,
y_0=0,
ellps="intl",
units="m",
towgs84="-122.74,-34.27,-22.83,-1.884,-3.400,-3.030,-15.62",
)
towgs84_test = [-122.74, -34.27, -22.83, -1.884, -3.4, -3.03, -15.62]
horizontal_datum_name = (
"Unknown based on International 1924 (Hayford 1909, 1910) ellipsoid"
)
if PROJ_GTE_901:
horizontal_datum_name = (
f"{horizontal_datum_name} using "
"towgs84=-122.74,-34.27,-22.83,-1.884,-3.400,-3.030,-15.62"
)
expected_cf = {
"semi_major_axis": 6378388.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": 297.0,
"reference_ellipsoid_name": "International 1924 (Hayford 1909, 1910)",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": horizontal_datum_name,
"towgs84": towgs84_test,
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_central_meridian": 15.0,
"false_easting": 2520000.0,
"false_northing": 0.0,
"scale_factor_at_central_meridian": 0.9996,
"geographic_crs_name": "unknown",
"projected_crs_name": "unknown",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("BOUNDCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "BOUNDCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
with pytest.warns(UserWarning):
assert crs.to_dict() == {
"proj": "tmerc",
"lat_0": 0,
"lon_0": 15,
"k": 0.9996,
"x_0": 2520000,
"y_0": 0,
"ellps": "intl",
"towgs84": towgs84_test,
"units": "m",
"no_defs": None,
"type": "crs",
}
@pytest.mark.parametrize(
"towgs84_test",
[
(-122.74, -34.27, -22.83, -1.884, -3.4, -3.03, -15.62),
"-122.74, -34.27, -22.83, -1.884, -3.4, -3.03, -15.62",
],
)
def test_from_cf_transverse_mercator(towgs84_test):
crs = CRS.from_cf(
{
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": 0,
"longitude_of_central_meridian": 15,
"false_easting": 2520000,
"false_northing": 0,
"reference_ellipsoid_name": "intl",
"towgs84": towgs84_test,
}
)
expected_cf = {
"semi_major_axis": 6378388.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": 297.0,
"reference_ellipsoid_name": "International 1924 (Hayford 1909, 1910)",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_central_meridian": 15.0,
"false_easting": 2520000.0,
"false_northing": 0.0,
"scale_factor_at_central_meridian": 1.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
"horizontal_datum_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("BOUNDCRS[")
assert_almost_equal(cf_dict.pop("towgs84"), _try_list_if_string(towgs84_test))
assert cf_dict == expected_cf
# test roundtrip
expected_cf["towgs84"] = _try_list_if_string(towgs84_test)
_test_roundtrip(expected_cf, "BOUNDCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_cf_from_latlon():
crs = CRS.from_cf(
dict(
grid_mapping_name="latitude_longitude",
semi_major_axis=6378137.0,
inverse_flattening=298.257223,
)
)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"grid_mapping_name": "latitude_longitude",
"geographic_crs_name": "undefined",
"reference_ellipsoid_name": "undefined",
"horizontal_datum_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("GEOGCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "GEOGCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"standard_name": "longitude",
"long_name": "longitude coordinate",
"units": "degrees_east",
"axis": "X",
},
{
"standard_name": "latitude",
"long_name": "latitude coordinate",
"units": "degrees_north",
"axis": "Y",
},
]
def test_cf_from_latlon__named():
crs = CRS.from_cf(dict(spatial_ref="epsg:4326"))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"geographic_crs_name": "WGS 84",
"grid_mapping_name": "latitude_longitude",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("GEOGCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "GEOGCRS[")
def test_cf_from_utm():
crs = CRS.from_cf(dict(crs_wkt="epsg:32615"))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "WGS 84",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"projected_crs_name": "WGS 84 / UTM zone 15N",
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_central_meridian": -93.0,
"false_easting": 500000.0,
"false_northing": 0.0,
"scale_factor_at_central_meridian": 0.9996,
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_cf_from_utm__nad83():
crs = CRS("epsg:26917")
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "GRS 1980",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "NAD83",
"horizontal_datum_name": "North American Datum 1983",
"projected_crs_name": "NAD83 / UTM zone 17N",
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_central_meridian": -81.0,
"false_easting": 500000.0,
"false_northing": 0.0,
"scale_factor_at_central_meridian": 0.9996,
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_cf_rotated_latlon():
crs = CRS.from_cf(
dict(
grid_mapping_name="rotated_latitude_longitude",
grid_north_pole_latitude=32.5,
grid_north_pole_longitude=170.0,
)
)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "rotated_latitude_longitude",
"grid_north_pole_latitude": 32.5,
"grid_north_pole_longitude": 170.0,
"north_pole_grid_longitude": 0.0,
"geographic_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("GEOGCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "GEOGCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"standard_name": "grid_longitude",
"long_name": "longitude in rotated pole grid",
"units": "degrees",
"axis": "X",
},
{
"standard_name": "grid_latitude",
"long_name": "latitude in rotated pole grid",
"units": "degrees",
"axis": "Y",
},
]
with pytest.warns(UserWarning):
proj_dict = crs.to_dict()
assert proj_dict == {
"proj": "ob_tran",
"o_proj": "longlat",
"o_lat_p": 32.5,
"o_lon_p": 0,
"lon_0": 350,
"datum": "WGS84",
"no_defs": None,
"type": "crs",
}
def test_cf_rotated_latlon__grid():
crs = CRS.from_cf(
dict(
grid_mapping_name="rotated_latitude_longitude",
grid_north_pole_latitude=32.5,
grid_north_pole_longitude=1.0,
north_pole_grid_longitude=170.0,
)
)
with pytest.warns(UserWarning):
proj_dict = crs.to_dict()
assert proj_dict == {
"proj": "ob_tran",
"o_proj": "longlat",
"o_lat_p": 32.5,
"o_lon_p": 170.0,
"lon_0": 181.0,
"datum": "WGS84",
"no_defs": None,
"type": "crs",
}
def test_rotated_pole_to_cf():
rotated_pole_wkt = (
'GEOGCRS["undefined",\n'
' BASEGEOGCRS["Unknown datum based upon the GRS 1980 ellipsoid",\n'
' DATUM["Not specified (based on GRS 1980 ellipsoid)",\n'
' ELLIPSOID["GRS 1980",6378137,298.257222101,\n'
' LENGTHUNIT["metre",1]]],\n'
' PRIMEM["Greenwich",0,\n'
' ANGLEUNIT["degree",0.0174532925199433]]],\n'
' DERIVINGCONVERSION["Pole rotation (netCDF CF convention)",\n'
' METHOD["Pole rotation (netCDF CF convention)"],\n'
' PARAMETER["Grid north pole latitude (netCDF CF '
'convention)",2,\n'
' ANGLEUNIT["degree",0.0174532925199433,\n'
' ID["EPSG",9122]]],\n'
' PARAMETER["Grid north pole longitude (netCDF CF '
'convention)",3,\n'
' ANGLEUNIT["degree",0.0174532925199433,\n'
' ID["EPSG",9122]]],\n'
' PARAMETER["North pole grid longitude (netCDF CF '
'convention)",4,\n'
' ANGLEUNIT["degree",0.0174532925199433,\n'
' ID["EPSG",9122]]]],\n'
" CS[ellipsoidal,2],\n"
' AXIS["geodetic latitude (Lat)",north,\n'
" ORDER[1],\n"
' ANGLEUNIT["degree",0.0174532925199433,\n'
' ID["EPSG",9122]]],\n'
' AXIS["geodetic longitude (Lon)",east,\n'
" ORDER[2],\n"
' ANGLEUNIT["degree",0.0174532925199433,\n'
' ID["EPSG",9122]]]]'
)
crs = CRS(rotated_pole_wkt)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": 6356752.314140356,
"inverse_flattening": 298.257222101,
"reference_ellipsoid_name": "GRS 1980",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "undefined",
"grid_mapping_name": "rotated_latitude_longitude",
"grid_north_pole_latitude": 2.0,
"grid_north_pole_longitude": 3.0,
"north_pole_grid_longitude": 4.0,
"horizontal_datum_name": "Not specified (based on GRS 1980 ellipsoid)",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("GEOGCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "GEOGCRS[")
def test_grib_rotated_pole_to_cf():
rotated_pole_wkt = """GEOGCRS["Coordinate System imported from GRIB file",
BASEGEOGCRS["Coordinate System imported from GRIB file",
DATUM["unnamed",
ELLIPSOID["Sphere",6371229,0,
LENGTHUNIT["metre",1,
ID["EPSG",9001]]]],
PRIMEM["Greenwich",0,
ANGLEUNIT["degree",0.0174532925199433,
ID["EPSG",9122]]]],
DERIVINGCONVERSION["Pole rotation (GRIB convention)",
METHOD["Pole rotation (GRIB convention)"],
PARAMETER["Latitude of the southern pole (GRIB convention)",-33.443381,
ANGLEUNIT["degree",0.0174532925199433,
ID["EPSG",9122]]],
PARAMETER["Longitude of the southern pole (GRIB convention)",-93.536426,
ANGLEUNIT["degree",0.0174532925199433,
ID["EPSG",9122]]],
PARAMETER["Axis rotation (GRIB convention)",0,
ANGLEUNIT["degree",0.0174532925199433,
ID["EPSG",9122]]]],
CS[ellipsoidal,2],
AXIS["latitude",north,
ORDER[1],
ANGLEUNIT["degree",0.0174532925199433,
ID["EPSG",9122]]],
AXIS["longitude",east,
ORDER[2],
ANGLEUNIT["degree",0.0174532925199433,
ID["EPSG",9122]]]]"""
crs = CRS(rotated_pole_wkt)
with pytest.warns(UserWarning):
cf_dict = crs.to_cf(errcheck=True)
assert cf_dict.pop("crs_wkt").startswith("GEOGCRS[")
assert not cf_dict
def test_cf_lambert_conformal_conic_1sp():
crs = CRS.from_cf(
dict(
grid_mapping_name="lambert_conformal_conic",
standard_parallel=25.0,
longitude_of_central_meridian=265.0,
latitude_of_projection_origin=25.0,
)
)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "lambert_conformal_conic",
"longitude_of_central_meridian": 265.0,
"false_easting": 0.0,
"false_northing": 0.0,
"standard_parallel": 25.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
with pytest.warns(UserWarning):
proj_dict = crs.to_dict()
assert proj_dict == {
"proj": "lcc",
"lat_1": 25,
"lat_0": 25,
"lon_0": 265,
"k_0": 1,
"x_0": 0,
"y_0": 0,
"datum": "WGS84",
"units": "m",
"no_defs": None,
"type": "crs",
}
@pytest.mark.parametrize("standard_parallel", [[25.0, 30.0], "25., 30."])
def test_cf_lambert_conformal_conic_2sp(standard_parallel):
crs = CRS.from_cf(
dict(
grid_mapping_name="lambert_conformal_conic",
standard_parallel=standard_parallel,
longitude_of_central_meridian=265.0,
latitude_of_projection_origin=25.0,
)
)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "lambert_conformal_conic",
"standard_parallel": (25.0, 30.0),
"latitude_of_projection_origin": 25.0,
"longitude_of_central_meridian": 265.0,
"false_easting": 0.0,
"false_northing": 0.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
with pytest.warns(UserWarning):
proj_dict = crs.to_dict()
assert proj_dict == {
"proj": "lcc",
"lat_1": 25,
"lat_2": 30,
"lat_0": 25,
"lon_0": 265,
"x_0": 0,
"y_0": 0,
"datum": "WGS84",
"units": "m",
"no_defs": None,
"type": "crs",
}
def test_oblique_mercator():
crs = CRS.from_cf(
dict(
grid_mapping_name="oblique_mercator",
azimuth_of_central_line=0.35,
latitude_of_projection_origin=10,
longitude_of_projection_origin=15,
reference_ellipsoid_name="WGS84",
false_easting=0.0,
false_northing=0.0,
)
)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"grid_mapping_name": "oblique_mercator",
"latitude_of_projection_origin": 10.0,
"longitude_of_projection_origin": 15.0,
"azimuth_of_central_line": 0.35,
"scale_factor_at_projection_origin": 1.0,
"false_easting": 0.0,
"false_northing": 0.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
"horizontal_datum_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
with pytest.warns(UserWarning):
assert crs.to_dict() == {
"proj": "omerc",
"lat_0": 10,
"lonc": 15,
"alpha": 0.35,
"gamma": 0,
"k": 1,
"x_0": 0,
"y_0": 0,
"ellps": "WGS84",
"units": "m",
"no_defs": None,
"type": "crs",
}
def test_oblique_mercator_losing_gamma():
crs = CRS(
"+proj=omerc +lat_0=-36.10360962430914 +lonc=147.0632291727015 "
"+alpha=-54.78622979612904 +k=1 +x_0=0 +y_0=0 +gamma=-54.78622979612904"
)
with pytest.warns(
UserWarning,
match="angle from rectified to skew grid parameter lost in conversion to CF",
):
crs.to_cf()
def test_cf_from_invalid():
with pytest.raises(CRSError):
CRS.from_cf(
dict(
longitude_of_central_meridian=265.0, latitude_of_projection_origin=25.0
)
)
with pytest.raises(CRSError):
CRS.from_cf(
dict(grid_mapping_name="invalid", latitude_of_projection_origin=25.0)
)
def test_geos_crs_sweep():
crs = CRS.from_cf(
dict(
grid_mapping_name="geostationary",
perspective_point_height=1,
sweep_angle_axis="x",
)
)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "geostationary",
"sweep_angle_axis": "x",
"perspective_point_height": 1.0,
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 0.0,
"false_easting": 0.0,
"false_northing": 0.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_geos_crs_fixed_angle_axis():
crs = CRS.from_cf(
dict(
grid_mapping_name="geostationary",
perspective_point_height=1,
fixed_angle_axis="y",
),
)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "geostationary",
"sweep_angle_axis": "x",
"perspective_point_height": 1.0,
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 0.0,
"false_easting": 0.0,
"false_northing": 0.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_geos_proj_string():
crs = CRS({"proj": "geos", "h": 35785831.0, "a": 6378169.0, "b": 6356583.8})
expected_cf = {
"semi_major_axis": 6378169.0,
"semi_minor_axis": 6356583.8,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"grid_mapping_name": "geostationary",
"sweep_angle_axis": "y",
"perspective_point_height": 35785831.0,
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 0.0,
"false_easting": 0.0,
"false_northing": 0.0,
"geographic_crs_name": "unknown",
"horizontal_datum_name": "unknown",
"projected_crs_name": "unknown",
"reference_ellipsoid_name": "unknown",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_ob_tran_not_rotated_latlon():
crs = CRS("+proj=ob_tran +o_proj=moll +o_lat_p=45 +o_lon_p=-90 +lon_0=-90")
with pytest.warns(UserWarning):
cf_dict = crs.to_cf(errcheck=True)
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == {}
def test_mercator_b():
crs = CRS.from_cf(
{
"grid_mapping_name": "mercator",
"longitude_of_projection_origin": 10,
"standard_parallel": 21.354,
"false_easting": 0,
"false_northing": 0,
}
)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "mercator",
"standard_parallel": 21.354,
"longitude_of_projection_origin": 10.0,
"false_easting": 0.0,
"false_northing": 0.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
with pytest.warns(UserWarning):
assert crs.to_dict() == {
"datum": "WGS84",
"lat_ts": 21.354,
"lon_0": 10,
"no_defs": None,
"proj": "merc",
"type": "crs",
"units": "m",
"x_0": 0,
"y_0": 0,
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_osgb_1936():
crs = CRS("OSGB 1936 / British National Grid")
param_dict = _to_dict(crs.coordinate_operation)
expected_cf = {
"semi_major_axis": crs.ellipsoid.semi_major_metre,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "Airy 1830",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "OSGB 1936",
"horizontal_datum_name": "OSGB 1936",
"projected_crs_name": "OSGB 1936 / British National Grid",
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": 49.0,
"longitude_of_central_meridian": -2.0,
"false_easting": 400000.0,
"false_northing": -100000.0,
"scale_factor_at_central_meridian": param_dict[
"Scale factor at natural origin"
],
}
if PROJ_LOOSE_VERSION >= version.parse("8.0.1"):
expected_cf.update(
geographic_crs_name="OSGB36",
horizontal_datum_name="Ordnance Survey of Great Britain 1936",
projected_crs_name="OSGB36 / British National Grid",
)
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_export_compound_crs():
crs = CRS("urn:ogc:def:crs,crs:EPSG::2393,crs:EPSG::5717")
expected_cf = {
"semi_major_axis": 6378388.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": 297.0,
"reference_ellipsoid_name": "International 1924",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "KKJ",
"horizontal_datum_name": "Kartastokoordinaattijarjestelma (1966)",
"projected_crs_name": "KKJ / Finland Uniform Coordinate System",
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_central_meridian": 27.0,
"false_easting": 3500000.0,
"false_northing": 0.0,
"scale_factor_at_central_meridian": 1.0,
"geopotential_datum_name": "Helsinki 1960",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("COMPOUNDCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "COMPOUNDCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"standard_name": "height_above_reference_ellipsoid",
"long_name": "Gravity-related height",
"units": "metre",
"positive": "up",
"axis": "Z",
},
]
def test_geoid_model_name():
wkt = (
'COMPOUNDCRS["NAD83 / Pennsylvania South + NAVD88 height",\n'
' PROJCRS["NAD83 / Pennsylvania South",\n'
' BASEGEOGCRS["NAD83",\n'
' DATUM["North American Datum 1983",\n'
' ELLIPSOID["GRS 1980",6378137,298.257222101,\n'
' LENGTHUNIT["metre",1]]],\n'
' PRIMEM["Greenwich",0,\n'
' ANGLEUNIT["degree",0.0174532925199433]]],\n'
' CONVERSION["SPCS83 Pennsylvania South zone (meters)",\n'
' METHOD["Lambert Conic Conformal (2SP)",\n'
' ID["EPSG",9802]],\n'
' PARAMETER["Latitude of false origin",39.3333333333333,\n'
' ANGLEUNIT["degree",0.0174532925199433],\n'
' ID["EPSG",8821]],\n'
' PARAMETER["Longitude of false origin",-77.75,\n'
' ANGLEUNIT["degree",0.0174532925199433],\n'
' ID["EPSG",8822]],\n'
' PARAMETER["Latitude of 1st standard '
'parallel",40.9666666666667,\n'
' ANGLEUNIT["degree",0.0174532925199433],\n'
' ID["EPSG",8823]],\n'
' PARAMETER["Latitude of 2nd standard '
'parallel",39.9333333333333,\n'
' ANGLEUNIT["degree",0.0174532925199433],\n'
' ID["EPSG",8824]],\n'
' PARAMETER["Easting at false origin",600000,\n'
' LENGTHUNIT["metre",1],\n'
' ID["EPSG",8826]],\n'
' PARAMETER["Northing at false origin",0,\n'
' LENGTHUNIT["metre",1],\n'
' ID["EPSG",8827]]],\n'
" CS[Cartesian,2],\n"
' AXIS["easting (X)",east,\n'
" ORDER[1],\n"
' LENGTHUNIT["metre",1]],\n'
' AXIS["northing (Y)",north,\n'
" ORDER[2],\n"
' LENGTHUNIT["metre",1]]],\n'
' VERTCRS["NAVD88 height",\n'
' VDATUM["North American Vertical Datum 1988"],\n'
" CS[vertical,1],\n"
' AXIS["gravity-related height (H)",up,\n'
' LENGTHUNIT["metre",1]],\n'
' GEOIDMODEL["GEOID12B"]]]'
)
crs = CRS(wkt)
param_dict = _to_dict(crs.sub_crs_list[0].coordinate_operation)
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "GRS 1980",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "NAD83",
"horizontal_datum_name": "North American Datum 1983",
"projected_crs_name": "NAD83 / Pennsylvania South",
"grid_mapping_name": "lambert_conformal_conic",
"standard_parallel": (
param_dict["Latitude of 1st standard parallel"],
param_dict["Latitude of 2nd standard parallel"],
),
"latitude_of_projection_origin": param_dict["Latitude of false origin"],
"longitude_of_central_meridian": -77.75,
"false_easting": 600000.0,
"false_northing": 0.0,
"geoid_name": "GEOID12B",
"geopotential_datum_name": "North American Vertical Datum 1988",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("COMPOUNDCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "COMPOUNDCRS[")
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
{
"standard_name": "height_above_reference_ellipsoid",
"long_name": "Gravity-related height",
"units": "metre",
"positive": "up",
"axis": "Z",
},
]
def test_albers_conical_equal_area():
crs = CRS("ESRI:102008")
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "GRS 1980",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "NAD83",
"horizontal_datum_name": "North American Datum 1983",
"projected_crs_name": "North_America_Albers_Equal_Area_Conic",
"grid_mapping_name": "albers_conical_equal_area",
"standard_parallel": (20.0, 60.0),
"latitude_of_projection_origin": 40.0,
"longitude_of_central_meridian": -96.0,
"false_easting": 0.0,
"false_northing": 0.0,
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_azimuthal_equidistant():
crs = CRS("ESRI:54032")
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "WGS 84",
"horizontal_datum_name": "World Geodetic System 1984",
"projected_crs_name": "World_Azimuthal_Equidistant",
"grid_mapping_name": "azimuthal_equidistant",
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 0.0,
"false_easting": 0.0,
"false_northing": 0.0,
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
expected_cf["horizontal_datum_name"] = "World Geodetic System 1984 ensemble"
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_lambert_azimuthal_equal_area():
crs = ProjectedCRS(conversion=LambertAzimuthalEqualAreaConversion(1, 2, 3, 4))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "lambert_azimuthal_equal_area",
"latitude_of_projection_origin": 1.0,
"longitude_of_projection_origin": 2.0,
"false_easting": 3.0,
"false_northing": 4.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_lambert_cylindrical_equal_area():
crs = ProjectedCRS(conversion=LambertCylindricalEqualAreaConversion(1, 2, 3, 4))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "lambert_cylindrical_equal_area",
"standard_parallel": 1.0,
"longitude_of_central_meridian": 2.0,
"false_easting": 3.0,
"false_northing": 4.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_mercator_a():
crs = ProjectedCRS(conversion=MercatorAConversion(0, 2, 3, 4))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "mercator",
"standard_parallel": 0.0,
"longitude_of_projection_origin": 2.0,
"false_easting": 3.0,
"false_northing": 4.0,
"scale_factor_at_projection_origin": 1.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_orthographic():
crs = ProjectedCRS(conversion=OrthographicConversion(1, 2, 3, 4))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "orthographic",
"latitude_of_projection_origin": 1.0,
"longitude_of_projection_origin": 2.0,
"false_easting": 3.0,
"false_northing": 4.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_polar_stereographic_a():
crs = ProjectedCRS(conversion=PolarStereographicAConversion(90, 1, 2, 3))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "polar_stereographic",
"latitude_of_projection_origin": 90.0,
"straight_vertical_longitude_from_pole": 1.0,
"false_easting": 2.0,
"false_northing": 3.0,
"scale_factor_at_projection_origin": 1.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_polar_stereographic_b():
crs = ProjectedCRS(conversion=PolarStereographicBConversion(0, 1, 2, 3))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "polar_stereographic",
"standard_parallel": 0.0,
"straight_vertical_longitude_from_pole": 1.0,
"false_easting": 2.0,
"false_northing": 3.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_stereographic():
crs = ProjectedCRS(conversion=StereographicConversion(0, 1, 2, 3))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "stereographic",
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 1.0,
"false_easting": 2.0,
"false_northing": 3.0,
"scale_factor_at_projection_origin": 1.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_sinusoidal():
crs = ProjectedCRS(conversion=SinusoidalConversion(0, 1, 2))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "sinusoidal",
"longitude_of_projection_origin": 0.0,
"false_easting": 1.0,
"false_northing": 2.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_vertical_perspective():
crs = ProjectedCRS(conversion=VerticalPerspectiveConversion(50, 0, 1, 0, 2, 3))
expected_cf = {
"semi_major_axis": 6378137.0,
"semi_minor_axis": crs.ellipsoid.semi_minor_metre,
"inverse_flattening": crs.ellipsoid.inverse_flattening,
"reference_ellipsoid_name": "WGS 84",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"horizontal_datum_name": "World Geodetic System 1984 ensemble",
"grid_mapping_name": "vertical_perspective",
"perspective_point_height": 50.0,
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 1.0,
"false_easting": 2.0,
"false_northing": 3.0,
"geographic_crs_name": "undefined",
"projected_crs_name": "undefined",
}
cf_dict = crs.to_cf()
assert cf_dict.pop("crs_wkt").startswith("PROJCRS[")
assert cf_dict == expected_cf
# test roundtrip
_test_roundtrip(expected_cf, "PROJCRS[")
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
]
def test_build_custom_datum():
cf_dict = {
"semi_major_axis": 6370997.0,
"semi_minor_axis": 6370997.0,
"inverse_flattening": 0.0,
"reference_ellipsoid_name": "Normal Sphere (r=6370997)",
"longitude_of_prime_meridian": 1.0,
"grid_mapping_name": "oblique_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 13.809602948622212,
"azimuth_of_central_line": 8.998112717187938,
"scale_factor_at_projection_origin": 1.0,
"false_easting": 0.0,
"false_northing": 0.0,
}
crs = CRS.from_cf(cf_dict)
assert crs.datum.name == "undefined"
assert crs.ellipsoid.name == "Normal Sphere (r=6370997)"
assert crs.prime_meridian.name == "undefined"
assert crs.prime_meridian.longitude == 1
def test_build_custom_datum__default_prime_meridian():
cf_dict = {
"semi_major_axis": 6370997.0,
"semi_minor_axis": 6370997.0,
"inverse_flattening": 0.0,
"grid_mapping_name": "oblique_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 13.809602948622212,
"azimuth_of_central_line": 8.998112717187938,
"scale_factor_at_projection_origin": 1.0,
"false_easting": 0.0,
"false_northing": 0.0,
}
crs = CRS.from_cf(cf_dict)
assert crs.datum.name == "undefined"
assert crs.ellipsoid.name == "undefined"
assert crs.prime_meridian.name == "Greenwich"
assert crs.prime_meridian.longitude == 0
def test_build_custom_datum__default_ellipsoid():
cf_dict = {
"prime_meridian_name": "Paris",
"grid_mapping_name": "oblique_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_projection_origin": 13.809602948622212,
"azimuth_of_central_line": 8.998112717187938,
"scale_factor_at_projection_origin": 1.0,
"false_easting": 0.0,
"false_northing": 0.0,
}
crs = CRS.from_cf(cf_dict)
assert crs.datum.name == "undefined"
assert crs.ellipsoid.name == "WGS 84"
assert crs.prime_meridian.name == "Paris"
assert str(crs.prime_meridian.longitude).startswith("2.")
def test_cartesian_cs():
unit = {"type": "LinearUnit", "name": "US Survey Foot", "conversion_factor": 0.3048}
cartesian_cs = {
"type": "CoordinateSystem",
"subtype": "Cartesian",
"axis": [
{"name": "Easting", "abbreviation": "E", "direction": "east", "unit": unit},
{
"name": "Northing",
"abbreviation": "N",
"direction": "north",
"unit": unit,
},
],
}
crs = CRS.from_cf(
{
"grid_mapping_name": "transverse_mercator",
"semi_major_axis": 6377563.396,
"inverse_flattening": 299.3249646,
"longitude_of_prime_meridian": 0.0,
"latitude_of_projection_origin": 49.0,
"longitude_of_central_meridian": -2.0,
"scale_factor_at_central_meridian": 0.9996012717,
"false_easting": 400000.0,
"false_northing": -100000.0,
},
cartesian_cs=cartesian_cs,
)
json_dict = crs.coordinate_system.to_json_dict()
json_dict.pop("$schema")
assert json_dict == cartesian_cs
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "0.3048 metre",
},
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "0.3048 metre",
},
]
def test_ellipsoidal_cs():
ellipsoidal_cs = {
"type": "CoordinateSystem",
"subtype": "ellipsoidal",
"axis": [
{
"name": "Latitude",
"abbreviation": "lat",
"direction": "north",
"unit": "degree",
},
{
"name": "Longitude",
"abbreviation": "lon",
"direction": "east",
"unit": "degree",
},
],
}
crs = CRS.from_cf(
dict(
grid_mapping_name="latitude_longitude",
semi_major_axis=6378137.0,
inverse_flattening=298.257223,
),
ellipsoidal_cs=ellipsoidal_cs,
)
json_dict = crs.coordinate_system.to_json_dict()
json_dict.pop("$schema")
assert json_dict == ellipsoidal_cs
# test coordinate system
assert crs.cs_to_cf() == [
{
"standard_name": "latitude",
"long_name": "latitude coordinate",
"units": "degrees_north",
"axis": "Y",
},
{
"standard_name": "longitude",
"long_name": "longitude coordinate",
"units": "degrees_east",
"axis": "X",
},
]
def test_ellipsoidal_cs__from_name():
ellipsoidal_cs = {
"type": "CoordinateSystem",
"subtype": "ellipsoidal",
"axis": [
{
"name": "Longitude",
"abbreviation": "lon",
"direction": "east",
"unit": "degree",
},
{
"name": "Latitude",
"abbreviation": "lat",
"direction": "north",
"unit": "degree",
},
],
}
crs = CRS.from_cf(
dict(grid_mapping_name="latitude_longitude", geographic_crs_name="WGS 84"),
ellipsoidal_cs=ellipsoidal_cs,
)
json_dict = crs.coordinate_system.to_json_dict()
json_dict.pop("$schema")
assert json_dict == ellipsoidal_cs
# test coordinate system
assert crs.cs_to_cf() == [
{
"standard_name": "longitude",
"long_name": "longitude coordinate",
"units": "degrees_east",
"axis": "X",
},
{
"standard_name": "latitude",
"long_name": "latitude coordinate",
"units": "degrees_north",
"axis": "Y",
},
]
def test_export_compound_crs_cs():
unit = {"type": "LinearUnit", "name": "US Survey Foot", "conversion_factor": 0.3048}
cartesian_cs = {
"type": "CoordinateSystem",
"subtype": "Cartesian",
"axis": [
{
"name": "Northing",
"abbreviation": "N",
"direction": "north",
"unit": unit,
},
{"name": "Easting", "abbreviation": "E", "direction": "east", "unit": unit},
],
}
vertical_cs = {
"type": "CoordinateSystem",
"subtype": "vertical",
"axis": [
{
"name": "Gravity-related height",
"abbreviation": "H",
"direction": "up",
"unit": unit,
}
],
}
crs = CRS.from_cf(
{
"semi_major_axis": 6378388.0,
"semi_minor_axis": 6356911.9461279465,
"inverse_flattening": 297.0,
"reference_ellipsoid_name": "International 1924",
"longitude_of_prime_meridian": 0.0,
"prime_meridian_name": "Greenwich",
"geographic_crs_name": "KKJ",
"horizontal_datum_name": "Kartastokoordinaattijarjestelma (1966)",
"projected_crs_name": "KKJ / Finland Uniform Coordinate System",
"grid_mapping_name": "transverse_mercator",
"latitude_of_projection_origin": 0.0,
"longitude_of_central_meridian": 27.0,
"false_easting": 3500000.0,
"false_northing": 0.0,
"scale_factor_at_central_meridian": 1.0,
"geopotential_datum_name": "Helsinki 1960",
},
cartesian_cs=cartesian_cs,
vertical_cs=vertical_cs,
)
cartesian_json_dict = crs.sub_crs_list[0].coordinate_system.to_json_dict()
cartesian_json_dict.pop("$schema")
vertical_json_dict = crs.sub_crs_list[1].coordinate_system.to_json_dict()
vertical_json_dict.pop("$schema")
assert cartesian_json_dict == cartesian_cs
assert vertical_json_dict == vertical_cs
# test coordinate system
assert crs.cs_to_cf() == [
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "0.3048 metre",
},
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "0.3048 metre",
},
{
"standard_name": "height_above_reference_ellipsoid",
"long_name": "Gravity-related height",
"units": "0.3048 metre",
"positive": "up",
"axis": "Z",
},
]
def test_ellipsoidal_cs__geodetic():
crs = CRS.from_epsg(4326)
crs.cs_to_cf() == [
{
"standard_name": "latitude",
"long_name": "geodetic latitude coordinate",
"units": "degrees_north",
"axis": "Y",
},
{
"standard_name": "longitude",
"long_name": "geodetic longitude coordinate",
"units": "degrees_east",
"axis": "X",
},
]
def test_3d_ellipsoidal_cs_depth():
crs = CRS(
{
"$schema": "https://proj.org/schemas/v0.2/projjson.schema.json",
"type": "GeographicCRS",
"name": "WGS 84 (geographic 3D)",
"datum": {
"type": "GeodeticReferenceFrame",
"name": "World Geodetic System 1984 ensemble",
"ellipsoid": {
"name": "WGS 84",
"semi_major_axis": 6378137,
"inverse_flattening": 298.257223563,
},
},
"coordinate_system": {
"subtype": "ellipsoidal",
"axis": [
{
"name": "Geodetic latitude",
"abbreviation": "Lat",
"direction": "north",
"unit": {
"type": "AngularUnit",
"name": "degree minute second hemisphere",
"conversion_factor": 0.0174532925199433,
},
},
{
"name": "Geodetic longitude",
"abbreviation": "Long",
"direction": "east",
"unit": {
"type": "AngularUnit",
"name": "degree minute second hemisphere",
"conversion_factor": 0.0174532925199433,
},
},
{
"name": "Ellipsoidal depth",
"abbreviation": "d",
"direction": "down",
"unit": "metre",
},
],
},
"area": "World",
"bbox": {
"south_latitude": -90,
"west_longitude": -180,
"north_latitude": 90,
"east_longitude": 180,
},
}
)
crs.cs_to_cf() == [
{
"standard_name": "latitude",
"long_name": "geodetic latitude coordinate",
"units": "degrees_north",
"axis": "Y",
},
{
"standard_name": "longitude",
"long_name": "geodetic longitude coordinate",
"units": "degrees_east",
"axis": "X",
},
{
"standard_name": "height_above_reference_ellipsoid",
"long_name": "Ellipsoidal depth",
"units": "metre",
"positive": "down",
"axis": "Z",
},
]
def test_decimal_year_temporal_crs__coordinate_system():
crs = CRS(
'TIMECRS["Decimal Years CE",\n'
' TDATUM["Common Era",\n'
' CALENDAR["proleptic Gregorian"],\n'
" TIMEORIGIN[0000]],\n"
" CS[TemporalMeasure,1],\n"
' AXIS["decimal years (a)",future,\n'
' TIMEUNIT["year"]]]'
)
assert crs.cs_to_cf() == [
{
"standard_name": "time",
"long_name": "time",
"calendar": "proleptic_gregorian",
"units": "year since 0000-01-01",
"axis": "T",
}
]
def test_datetime_temporal_crs__coordinate_system():
crs = CRS(
"TIMECRS[“DateTime”,"
"TDATUM[“Gregorian Calendar”],"
'CS[TemporalDateTime,1],AXIS["Time (T)",future]]'
)
assert crs.cs_to_cf() == [
{
"standard_name": "time",
"long_name": "time",
"calendar": "proleptic_gregorian",
"axis": "T",
}
]
def test_count_temporal_crs__coordinate_system():
crs = CRS(
"TIMECRS[“Calendar hours from 1979-12-29”,"
"TDATUM[“29 December 1979”,TIMEORIGIN[1979-12-29T00Z]],"
"CS[TemporalCount,1],AXIS[“Time”,future,TIMEUNIT[“hour”]]]"
)
assert crs.cs_to_cf() == [
{
"standard_name": "time",
"long_name": "time",
"calendar": "proleptic_gregorian",
"units": "hour since 1979-12-29T00",
"axis": "T",
}
]
def test_unix_temporal_crs__coordinate_system():
crs = CRS(
"TIMECRS[“Unix time”,"
"TDATUM[“Unix epoch”,TIMEORIGIN[1970-01-01T00:00:00Z]],"
"CS[TemporalCount,1],AXIS[“Time”,future,TIMEUNIT[“second”]]]"
)
assert crs.cs_to_cf() == [
{
"standard_name": "time",
"long_name": "time",
"calendar": "proleptic_gregorian",
"units": "second since 1970-01-01T00:00:00",
"axis": "T",
}
]
def test_milisecond_temporal_crs__coordinate_system():
crs = CRS(
'TIMECRS["GPS milliseconds",'
'TDATUM["GPS time origin",TIMEORIGIN[1980-01-01T00:00:00.0Z]],'
"CS[TemporalCount,1],"
'AXIS["(T)",future,TIMEUNIT["millisecond",0.001]]]'
)
assert crs.cs_to_cf() == [
{
"standard_name": "time",
"long_name": "time",
"calendar": "proleptic_gregorian",
"units": "millisecond since 1980-01-01T00:00:00.0",
"axis": "T",
}
]
pyproj-3.6.1/test/crs/test_crs_coordinate_operation.py 0000664 0000000 0000000 00000056632 14502715416 0023322 0 ustar 00root root 0000000 0000000 import pytest
from numpy.testing import assert_almost_equal
from pyproj.crs import GeographicCRS
from pyproj.crs.coordinate_operation import (
AlbersEqualAreaConversion,
AzimuthalEquidistantConversion,
EquidistantCylindricalConversion,
GeostationarySatelliteConversion,
HotineObliqueMercatorBConversion,
LambertAzimuthalEqualAreaConversion,
LambertConformalConic1SPConversion,
LambertConformalConic2SPConversion,
LambertCylindricalEqualAreaConversion,
LambertCylindricalEqualAreaScaleConversion,
MercatorAConversion,
MercatorBConversion,
OrthographicConversion,
PlateCarreeConversion,
PolarStereographicAConversion,
PolarStereographicBConversion,
PoleRotationNetCDFCFConversion,
RotatedLatitudeLongitudeConversion,
SinusoidalConversion,
StereographicConversion,
ToWGS84Transformation,
TransverseMercatorConversion,
UTMConversion,
VerticalPerspectiveConversion,
)
from pyproj.exceptions import CRSError
def _to_dict(operation):
param_dict = {}
for param in operation.params:
param_dict[param.name] = param.value
return param_dict
def test_albers_equal_area_operation__defaults():
aeaop = AlbersEqualAreaConversion(
latitude_first_parallel=1, latitude_second_parallel=2
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Albers Equal Area"
assert _to_dict(aeaop) == {
"Easting at false origin": 0.0,
"Latitude of 1st standard parallel": 1.0,
"Latitude of 2nd standard parallel": 2.0,
"Latitude of false origin": 0.0,
"Longitude of false origin": 0.0,
"Northing at false origin": 0.0,
}
def test_albers_equal_area_operation():
aeaop = AlbersEqualAreaConversion(
latitude_first_parallel=1,
latitude_second_parallel=2,
latitude_false_origin=3,
longitude_false_origin=4,
easting_false_origin=5,
northing_false_origin=6,
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Albers Equal Area"
assert _to_dict(aeaop) == {
"Easting at false origin": 5.0,
"Latitude of 1st standard parallel": 1.0,
"Latitude of 2nd standard parallel": 2.0,
"Latitude of false origin": 3.0,
"Longitude of false origin": 4.0,
"Northing at false origin": 6.0,
}
def test_azimuthal_equidistant_operation__defaults():
aeop = AzimuthalEquidistantConversion()
assert aeop.name == "unknown"
assert aeop.method_name == "Modified Azimuthal Equidistant"
assert _to_dict(aeop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_azimuthal_equidistant_operation():
aeop = AzimuthalEquidistantConversion(
latitude_natural_origin=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
)
assert aeop.name == "unknown"
assert aeop.method_name == "Modified Azimuthal Equidistant"
assert _to_dict(aeop) == {
"Latitude of natural origin": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
}
def test_geostationary_operation__defaults():
geop = GeostationarySatelliteConversion(sweep_angle_axis="x", satellite_height=10)
assert geop.name == "unknown"
assert geop.method_name == "Geostationary Satellite (Sweep X)"
assert _to_dict(geop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
"Satellite height": 10.0,
}
def test_geostationary_operation():
with pytest.warns(UserWarning):
geop = GeostationarySatelliteConversion(
sweep_angle_axis="y",
satellite_height=11,
latitude_natural_origin=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
)
assert geop.name == "unknown"
assert geop.method_name == "Geostationary Satellite (Sweep Y)"
assert _to_dict(geop) == {
"Latitude of natural origin": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
"Satellite height": 11.0,
}
def test_geostationary_operation__invalid_sweep():
with pytest.raises(CRSError):
GeostationarySatelliteConversion(sweep_angle_axis="P", satellite_height=10)
def test_lambert_azimuthal_equal_area_operation__defaults():
aeop = LambertAzimuthalEqualAreaConversion()
assert aeop.name == "unknown"
assert aeop.method_name == "Lambert Azimuthal Equal Area"
assert _to_dict(aeop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_lambert_azimuthal_equal_area_operation():
aeop = LambertAzimuthalEqualAreaConversion(
latitude_natural_origin=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
)
assert aeop.name == "unknown"
assert aeop.method_name == "Lambert Azimuthal Equal Area"
assert _to_dict(aeop) == {
"Latitude of natural origin": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
}
def test_lambert_conformat_conic_2sp_operation__defaults():
aeaop = LambertConformalConic2SPConversion(
latitude_first_parallel=1, latitude_second_parallel=2
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Lambert Conic Conformal (2SP)"
assert _to_dict(aeaop) == {
"Easting at false origin": 0.0,
"Latitude of 1st standard parallel": 1.0,
"Latitude of 2nd standard parallel": 2.0,
"Latitude of false origin": 0.0,
"Longitude of false origin": 0.0,
"Northing at false origin": 0.0,
}
def test_lambert_conformat_conic_2sp_operation():
aeaop = LambertConformalConic2SPConversion(
latitude_first_parallel=1,
latitude_second_parallel=2,
latitude_false_origin=3,
longitude_false_origin=4,
easting_false_origin=5,
northing_false_origin=6,
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Lambert Conic Conformal (2SP)"
assert _to_dict(aeaop) == {
"Easting at false origin": 5.0,
"Latitude of 1st standard parallel": 1.0,
"Latitude of 2nd standard parallel": 2.0,
"Latitude of false origin": 3.0,
"Longitude of false origin": 4.0,
"Northing at false origin": 6.0,
}
def test_lambert_conformat_conic_1sp_operation__defaults():
aeaop = LambertConformalConic1SPConversion()
assert aeaop.name == "unknown"
assert aeaop.method_name == "Lambert Conic Conformal (1SP)"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
"Scale factor at natural origin": 1.0,
}
def test_lambert_conformat_conic_1sp_operation():
aeaop = LambertConformalConic1SPConversion(
latitude_natural_origin=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
scale_factor_natural_origin=0.5,
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Lambert Conic Conformal (1SP)"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
"Scale factor at natural origin": 0.5,
}
def test_lambert_cylindrical_area_operation__defaults():
lceaop = LambertCylindricalEqualAreaConversion()
assert lceaop.name == "unknown"
assert lceaop.method_name == "Lambert Cylindrical Equal Area"
assert _to_dict(lceaop) == {
"Latitude of 1st standard parallel": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_lambert_cylindrical_equal_area_operation():
lceaop = LambertCylindricalEqualAreaConversion(
latitude_first_parallel=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
)
assert lceaop.name == "unknown"
assert lceaop.method_name == "Lambert Cylindrical Equal Area"
assert _to_dict(lceaop) == {
"Latitude of 1st standard parallel": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
}
def test_mercator_a_operation__defaults():
aeaop = MercatorAConversion()
assert aeaop.name == "unknown"
assert aeaop.method_name == "Mercator (variant A)"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
"Scale factor at natural origin": 1.0,
}
def test_mercator_a_operation():
aeaop = MercatorAConversion(
latitude_natural_origin=0,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
scale_factor_natural_origin=0.5,
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Mercator (variant A)"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
"Scale factor at natural origin": 0.5,
}
def test_mercator_a_operation__invalid_lat0():
with pytest.raises(CRSError):
MercatorAConversion(latitude_natural_origin=1)
def test_mercator_b_operation__defaults():
lceaop = MercatorBConversion()
assert lceaop.name == "unknown"
assert lceaop.method_name == "Mercator (variant B)"
assert _to_dict(lceaop) == {
"Latitude of 1st standard parallel": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_mercator_b_operation():
lceaop = MercatorBConversion(
latitude_first_parallel=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
)
assert lceaop.name == "unknown"
assert lceaop.method_name == "Mercator (variant B)"
assert _to_dict(lceaop) == {
"Latitude of 1st standard parallel": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
}
def test_hotline_oblique_mercator_b_operation__defaults():
hop = HotineObliqueMercatorBConversion(
latitude_projection_centre=0,
longitude_projection_centre=0,
azimuth_initial_line=0,
angle_from_rectified_to_skew_grid=0,
)
assert hop.name == "unknown"
assert hop.method_name == "Hotine Oblique Mercator (variant B)"
assert _to_dict(hop) == {
"Latitude of projection centre": 0.0,
"Longitude of projection centre": 0.0,
"Azimuth of initial line": 0.0,
"Angle from Rectified to Skew Grid": 0.0,
"Scale factor on initial line": 1.0,
"Easting at projection centre": 0.0,
"Northing at projection centre": 0.0,
}
def test_hotline_oblique_mercator_b_operation():
hop = HotineObliqueMercatorBConversion(
latitude_projection_centre=1,
longitude_projection_centre=2,
azimuth_initial_line=3,
angle_from_rectified_to_skew_grid=4,
scale_factor_on_initial_line=0.5,
easting_projection_centre=6,
northing_projection_centre=7,
)
assert hop.name == "unknown"
assert hop.method_name == "Hotine Oblique Mercator (variant B)"
assert _to_dict(hop) == {
"Latitude of projection centre": 1.0,
"Longitude of projection centre": 2.0,
"Azimuth of initial line": 3.0,
"Angle from Rectified to Skew Grid": 4.0,
"Scale factor on initial line": 0.5,
"Easting at projection centre": 6.0,
"Northing at projection centre": 7.0,
}
def test_orthographic_operation__defaults():
aeop = OrthographicConversion()
assert aeop.name == "unknown"
assert aeop.method_name == "Orthographic"
assert _to_dict(aeop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_orthographic_operation():
aeop = OrthographicConversion(
latitude_natural_origin=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
)
assert aeop.name == "unknown"
assert aeop.method_name == "Orthographic"
assert _to_dict(aeop) == {
"Latitude of natural origin": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
}
def test_polar_stereographic_a_operation__defaults():
aeaop = PolarStereographicAConversion(90)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Polar Stereographic (variant A)"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 90.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
"Scale factor at natural origin": 1.0,
}
def test_polar_stereographic_a_operation():
aeaop = PolarStereographicAConversion(
latitude_natural_origin=-90,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
scale_factor_natural_origin=0.5,
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Polar Stereographic (variant A)"
assert _to_dict(aeaop) == {
"Latitude of natural origin": -90.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
"Scale factor at natural origin": 0.5,
}
def test_polar_stereographic_b_operation__defaults():
aeop = PolarStereographicBConversion()
assert aeop.name == "unknown"
assert aeop.method_name == "Polar Stereographic (variant B)"
assert _to_dict(aeop) == {
"Latitude of standard parallel": 0.0,
"Longitude of origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_polar_stereographic_b_operation():
aeop = PolarStereographicBConversion(
latitude_standard_parallel=1,
longitude_origin=2,
false_easting=3,
false_northing=4,
)
assert aeop.name == "unknown"
assert aeop.method_name == "Polar Stereographic (variant B)"
assert _to_dict(aeop) == {
"Latitude of standard parallel": 1.0,
"Longitude of origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
}
def test_sinusoidal_operation__defaults():
aeop = SinusoidalConversion()
assert aeop.name == "unknown"
assert aeop.method_name == "Sinusoidal"
assert _to_dict(aeop) == {
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_sinusoidal_operation():
aeop = SinusoidalConversion(
longitude_natural_origin=2, false_easting=3, false_northing=4
)
assert aeop.name == "unknown"
assert aeop.method_name == "Sinusoidal"
assert _to_dict(aeop) == {
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
}
def test_stereographic_operation__defaults():
aeaop = StereographicConversion()
assert aeaop.name == "unknown"
assert aeaop.method_name == "Stereographic"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
"Scale factor at natural origin": 1.0,
}
def test_stereographic_operation():
aeaop = StereographicConversion(
latitude_natural_origin=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
scale_factor_natural_origin=0.5,
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Stereographic"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
"Scale factor at natural origin": 0.5,
}
def test_utm_operation__defaults():
aeop = UTMConversion(zone=2)
assert aeop.name == "UTM zone 2N"
assert aeop.method_name == "Transverse Mercator"
def test_utm_operation():
aeop = UTMConversion(zone=2, hemisphere="s")
assert aeop.name == "UTM zone 2S"
assert aeop.method_name == "Transverse Mercator"
def test_transverse_mercator_operation__defaults():
aeaop = TransverseMercatorConversion()
assert aeaop.name == "unknown"
assert aeaop.method_name == "Transverse Mercator"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
"Scale factor at natural origin": 1.0,
}
def test_transverse_mercator_operation():
aeaop = TransverseMercatorConversion(
latitude_natural_origin=1,
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
scale_factor_natural_origin=0.5,
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Transverse Mercator"
assert _to_dict(aeaop) == {
"Latitude of natural origin": 1.0,
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
"Scale factor at natural origin": 0.5,
}
def test_vertical_perspective_operation__defaults():
aeaop = VerticalPerspectiveConversion(viewpoint_height=10)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Vertical Perspective"
assert _to_dict(aeaop) == {
"Latitude of topocentric origin": 0.0,
"Longitude of topocentric origin": 0.0,
"Ellipsoidal height of topocentric origin": 0.0,
"Viewpoint height": 10.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_vertical_perspective_operation():
aeaop = VerticalPerspectiveConversion(
viewpoint_height=10,
latitude_topocentric_origin=1,
longitude_topocentric_origin=2,
false_easting=3,
false_northing=4,
ellipsoidal_height_topocentric_origin=5,
)
assert aeaop.name == "unknown"
assert aeaop.method_name == "Vertical Perspective"
assert _to_dict(aeaop) == {
"Latitude of topocentric origin": 1.0,
"Longitude of topocentric origin": 2.0,
"Ellipsoidal height of topocentric origin": 5.0,
"Viewpoint height": 10.0,
"False easting": 3.0,
"False northing": 4.0,
}
def test_rotated_latitude_longitude_operation__defaults():
aeaop = RotatedLatitudeLongitudeConversion(o_lat_p=1, o_lon_p=2)
assert aeaop.name == "unknown"
assert aeaop.method_name == "PROJ ob_tran o_proj=longlat"
assert _to_dict(aeaop) == {"o_lat_p": 1.0, "o_lon_p": 2.0, "lon_0": 0.0}
def test_rotated_latitude_longitude_operation():
aeaop = RotatedLatitudeLongitudeConversion(o_lat_p=1, o_lon_p=2, lon_0=3)
assert aeaop.name == "unknown"
assert aeaop.method_name == "PROJ ob_tran o_proj=longlat"
assert _to_dict(aeaop) == {"o_lat_p": 1.0, "o_lon_p": 2.0, "lon_0": 3.0}
def test_pole_rotation_netcdf_cf_convention__defaults():
poleop = PoleRotationNetCDFCFConversion(
grid_north_pole_latitude=1, grid_north_pole_longitude=2
)
assert poleop.name == "Pole rotation (netCDF CF convention)"
assert poleop.method_name == "Pole rotation (netCDF CF convention)"
assert _to_dict(poleop) == {
"Grid north pole latitude (netCDF CF convention)": 1.0,
"Grid north pole longitude (netCDF CF convention)": 2.0,
"North pole grid longitude (netCDF CF convention)": 0.0,
}
def test_pole_rotation_netcdf_cf_convention():
poleop = PoleRotationNetCDFCFConversion(
grid_north_pole_latitude=1,
grid_north_pole_longitude=2,
north_pole_grid_longitude=10,
)
assert poleop.name == "Pole rotation (netCDF CF convention)"
assert poleop.method_name == "Pole rotation (netCDF CF convention)"
assert _to_dict(poleop) == {
"Grid north pole latitude (netCDF CF convention)": 1.0,
"Grid north pole longitude (netCDF CF convention)": 2.0,
"North pole grid longitude (netCDF CF convention)": 10.0,
}
def test_lambert_cylindrical_equal_area_scale_operation__defaults():
lceaop = LambertCylindricalEqualAreaScaleConversion()
assert lceaop.name == "unknown"
assert lceaop.method_name == "Lambert Cylindrical Equal Area"
assert _to_dict(lceaop) == {
"Latitude of 1st standard parallel": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
def test_lambert_cylindrical_equal_area_scale_operation():
lceaop = LambertCylindricalEqualAreaScaleConversion(
longitude_natural_origin=2,
false_easting=3,
false_northing=4,
scale_factor_natural_origin=0.999,
)
assert lceaop.name == "unknown"
assert lceaop.method_name == "Lambert Cylindrical Equal Area"
op_dict = _to_dict(lceaop)
assert_almost_equal(
op_dict.pop("Latitude of 1st standard parallel"), 2.57, decimal=2
)
assert op_dict == {
"Longitude of natural origin": 2.0,
"False easting": 3.0,
"False northing": 4.0,
}
@pytest.mark.parametrize(
"eqc_class", [EquidistantCylindricalConversion, PlateCarreeConversion]
)
def test_equidistant_cylindrical_conversion__defaults(eqc_class):
eqc = eqc_class()
assert eqc.name == "unknown"
assert eqc.method_name == "Equidistant Cylindrical"
assert _to_dict(eqc) == {
"Latitude of 1st standard parallel": 0.0,
"Latitude of natural origin": 0.0,
"Longitude of natural origin": 0.0,
"False easting": 0.0,
"False northing": 0.0,
}
@pytest.mark.parametrize(
"eqc_class", [EquidistantCylindricalConversion, PlateCarreeConversion]
)
def test_equidistant_cylindrical_conversion(eqc_class):
eqc = eqc_class(
latitude_first_parallel=1.0,
latitude_natural_origin=2.0,
longitude_natural_origin=3.0,
false_easting=4.0,
false_northing=5.0,
)
assert eqc.name == "unknown"
assert eqc.method_name == "Equidistant Cylindrical"
assert _to_dict(eqc) == {
"Latitude of 1st standard parallel": 1.0,
"Latitude of natural origin": 2.0,
"Longitude of natural origin": 3.0,
"False easting": 4.0,
"False northing": 5.0,
}
def test_towgs84_transformation():
transformation = ToWGS84Transformation(GeographicCRS(), 1, 2, 3, 4, 5, 6, 7)
assert transformation.towgs84 == [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]
assert _to_dict(transformation) == {
"Scale difference": 7.0,
"X-axis rotation": 4.0,
"X-axis translation": 1.0,
"Y-axis rotation": 5.0,
"Y-axis translation": 2.0,
"Z-axis rotation": 6.0,
"Z-axis translation": 3.0,
}
def test_towgs84_transformation__defaults():
transformation = ToWGS84Transformation(GeographicCRS())
assert transformation.towgs84 == [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
assert _to_dict(transformation) == {
"Scale difference": 0.0,
"X-axis rotation": 0.0,
"X-axis translation": 0.0,
"Y-axis rotation": 0.0,
"Y-axis translation": 0.0,
"Z-axis rotation": 0.0,
"Z-axis translation": 0.0,
}
pyproj-3.6.1/test/crs/test_crs_coordinate_system.py 0000664 0000000 0000000 00000016676 14502715416 0022652 0 ustar 00root root 0000000 0000000 import pytest
from pyproj.crs.coordinate_system import (
Cartesian2DCS,
Ellipsoidal2DCS,
Ellipsoidal3DCS,
VerticalCS,
)
from pyproj.crs.enums import (
Cartesian2DCSAxis,
Ellipsoidal2DCSAxis,
Ellipsoidal3DCSAxis,
VerticalCSAxis,
)
@pytest.mark.parametrize(
"axis, direction, unit_name",
[
("UP", "up", "metre"),
(VerticalCSAxis.UP, "up", "metre"),
(VerticalCSAxis.UP_US_FT, "up", "US survey foot"),
("UP_FT", "up", "foot"),
(VerticalCSAxis.DEPTH, "down", "metre"),
(VerticalCSAxis.DEPTH_US_FT, "down", "US survey foot"),
("DEPTH_FT", "down", "foot"),
(VerticalCSAxis.GRAVITY_HEIGHT_US_FT, "up", "US survey foot"),
("GRAVITY_HEIGHT_FT", "up", "foot"),
],
)
def test_vertical_cs(axis, direction, unit_name):
vcs = VerticalCS(axis=axis)
assert len(vcs.axis_list) == 1
assert vcs.axis_list[0].direction == direction
assert vcs.axis_list[0].unit_name == unit_name
@pytest.mark.parametrize(
"axis, name_0, direction_0, name_1, direction_1, unit",
[
("EASTING_NORTHING", "Easting", "east", "Northing", "north", "metre"),
(
Cartesian2DCSAxis.NORTHING_EASTING,
"Northing",
"north",
"Easting",
"east",
"metre",
),
("EASTING_NORTHING_FT", "Easting", "east", "Northing", "north", "foot"),
(
Cartesian2DCSAxis.NORTHING_EASTING_FT,
"Northing",
"north",
"Easting",
"east",
"foot",
),
(
"EASTING_NORTHING_US_FT",
"Easting",
"east",
"Northing",
"north",
"US survey foot",
),
(
Cartesian2DCSAxis.NORTHING_EASTING_US_FT,
"Northing",
"north",
"Easting",
"east",
"US survey foot",
),
(
"NORTH_POLE_EASTING_SOUTH_NORTHING_SOUTH",
"Easting",
"south",
"Northing",
"south",
"metre",
),
(
Cartesian2DCSAxis.SOUTH_POLE_EASTING_NORTH_NORTHING_NORTH,
"Easting",
"north",
"Northing",
"north",
"metre",
),
("WESTING_SOUTHING", "Easting", "west", "Northing", "south", "metre"),
],
)
def test_cartesian_2d_cs(axis, name_0, direction_0, name_1, direction_1, unit):
vcs = Cartesian2DCS(axis=axis)
assert len(vcs.axis_list) == 2
assert vcs.axis_list[0].direction == direction_0
assert vcs.axis_list[0].name == name_0
assert vcs.axis_list[0].unit_name == unit
assert vcs.axis_list[1].direction == direction_1
assert vcs.axis_list[1].name == name_1
assert vcs.axis_list[1].unit_name == unit
@pytest.mark.parametrize(
"axis, name_0, direction_0, name_1, direction_1",
[
(
Ellipsoidal2DCSAxis.LONGITUDE_LATITUDE,
"Longitude",
"east",
"Latitude",
"north",
),
(
Ellipsoidal2DCSAxis.LATITUDE_LONGITUDE,
"Latitude",
"north",
"Longitude",
"east",
),
],
)
def test_ellipsoidal_2d_cs(axis, name_0, direction_0, name_1, direction_1):
vcs = Ellipsoidal2DCS(axis=axis)
assert len(vcs.axis_list) == 2
assert vcs.axis_list[0].direction == direction_0
assert vcs.axis_list[0].name == name_0
assert vcs.axis_list[0].unit_name == "degree"
assert vcs.axis_list[1].direction == direction_1
assert vcs.axis_list[1].name == name_1
assert vcs.axis_list[1].unit_name == "degree"
@pytest.mark.parametrize(
"axis, name_0, direction_0, name_1, direction_1",
[
(
Ellipsoidal3DCSAxis.LONGITUDE_LATITUDE_HEIGHT,
"Longitude",
"east",
"Latitude",
"north",
),
(
Ellipsoidal3DCSAxis.LATITUDE_LONGITUDE_HEIGHT,
"Latitude",
"north",
"Longitude",
"east",
),
],
)
def test_ellipsoidal_3d_cs(axis, name_0, direction_0, name_1, direction_1):
vcs = Ellipsoidal3DCS(axis=axis)
assert len(vcs.axis_list) == 3
assert vcs.axis_list[0].direction == direction_0
assert vcs.axis_list[0].name == name_0
assert vcs.axis_list[0].unit_name == "degree"
assert vcs.axis_list[1].direction == direction_1
assert vcs.axis_list[1].name == name_1
assert vcs.axis_list[1].unit_name == "degree"
assert vcs.axis_list[2].direction == "up"
assert vcs.axis_list[2].name == "Ellipsoidal height"
assert vcs.axis_list[2].unit_name == "metre"
def test_ellipsoidal2dcs_to_cf():
ecs = Ellipsoidal2DCS(axis=Ellipsoidal2DCSAxis.LATITUDE_LONGITUDE)
assert ecs.to_cf() == [
{
"standard_name": "latitude",
"long_name": "latitude coordinate",
"units": "degrees_north",
"axis": "Y",
},
{
"standard_name": "longitude",
"long_name": "longitude coordinate",
"units": "degrees_east",
"axis": "X",
},
]
def test_ellipsoidal3dcs_to_cf():
ecs = Ellipsoidal3DCS(axis=Ellipsoidal3DCSAxis.LONGITUDE_LATITUDE_HEIGHT)
assert ecs.to_cf() == [
{
"standard_name": "longitude",
"long_name": "longitude coordinate",
"units": "degrees_east",
"axis": "X",
},
{
"standard_name": "latitude",
"long_name": "latitude coordinate",
"units": "degrees_north",
"axis": "Y",
},
{
"standard_name": "height_above_reference_ellipsoid",
"long_name": "Ellipsoidal height",
"units": "metre",
"positive": "up",
"axis": "Z",
},
]
def test_cartesian2dcs_ft_to_cf():
csft = Cartesian2DCS(axis=Cartesian2DCSAxis.NORTHING_EASTING_FT)
csft.to_cf() == [
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "0.3048 metre",
},
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "0.3048 metre",
},
]
def test_cartesian2dcs_to_cf():
csm = Cartesian2DCS(axis=Cartesian2DCSAxis.EASTING_NORTHING_FT)
csm.to_cf() == [
{
"axis": "Y",
"long_name": "Northing",
"standard_name": "projection_y_coordinate",
"units": "metre",
},
{
"axis": "X",
"long_name": "Easting",
"standard_name": "projection_x_coordinate",
"units": "metre",
},
]
def test_verticalcs_depth_to_cf():
vcs = VerticalCS(axis=VerticalCSAxis.DEPTH)
vcs.to_cf() == [
{
"standard_name": "height_above_reference_ellipsoid",
"long_name": "Depth",
"units": "metre",
"positive": "down",
"axis": "Z",
}
]
def test_verticalcs_height_to_cf():
vcs = VerticalCS(axis=VerticalCSAxis.GRAVITY_HEIGHT_US_FT)
vcs.to_cf() == [
{
"standard_name": "height_above_reference_ellipsoid",
"long_name": "Gravity-related height",
"units": "0.304800609601219 metre",
"positive": "up",
"axis": "Z",
}
]
pyproj-3.6.1/test/crs/test_crs_datum.py 0000664 0000000 0000000 00000004110 14502715416 0020205 0 ustar 00root root 0000000 0000000 from numpy.testing import assert_almost_equal
from pyproj.crs.datum import (
CustomDatum,
CustomEllipsoid,
CustomPrimeMeridian,
Ellipsoid,
PrimeMeridian,
)
def test_custom_datum():
cd = CustomDatum()
assert cd.ellipsoid.name == "WGS 84"
assert cd.prime_meridian.name == "Greenwich"
def test_custom_datum__input():
cd = CustomDatum(
ellipsoid=Ellipsoid.from_epsg(7001),
prime_meridian=PrimeMeridian.from_name("Lisbon"),
)
assert cd.ellipsoid.name == "Airy 1830"
assert cd.prime_meridian.name == "Lisbon"
def test_custom_ellipsoid():
ce = CustomEllipsoid(semi_major_axis=6378137, inverse_flattening=298.257222101)
assert ce.name == "undefined"
assert ce.semi_major_metre == 6378137
assert ce.semi_minor_metre == 6356752.314140356
assert_almost_equal(ce.inverse_flattening, 298.257222101)
assert sorted(ce.to_json_dict()) == [
"$schema",
"inverse_flattening",
"name",
"semi_major_axis",
"type",
]
def test_custom_ellipsoid__minor():
ce = CustomEllipsoid(
name="test", semi_major_axis=6378137, semi_minor_axis=6356752.314
)
assert ce.name == "test"
assert ce.semi_major_metre == 6378137
assert ce.semi_minor_metre == 6356752.314
assert_almost_equal(ce.inverse_flattening, 298.25722014)
assert sorted(ce.to_json_dict()) == [
"$schema",
"name",
"semi_major_axis",
"semi_minor_axis",
"type",
]
def test_custom_ellipsoid__radius():
ce = CustomEllipsoid(radius=6378137)
assert ce.name == "undefined"
assert ce.semi_major_metre == 6378137
assert ce.semi_minor_metre == 6378137
assert ce.inverse_flattening == 0
assert sorted(ce.to_json_dict()) == ["$schema", "name", "radius", "type"]
def test_custom_prime_meridian():
pm = CustomPrimeMeridian(longitude=2)
assert pm.name == "undefined"
assert pm.longitude == 2
def test_custom_prime_meridian__name():
pm = CustomPrimeMeridian(longitude=1, name="frank")
assert pm.name == "frank"
assert pm.longitude == 1
pyproj-3.6.1/test/crs/test_crs_json.py 0000664 0000000 0000000 00000010526 14502715416 0020054 0 ustar 00root root 0000000 0000000 import pytest
from pyproj.crs import (
CRS,
CoordinateOperation,
CoordinateSystem,
Datum,
Ellipsoid,
PrimeMeridian,
)
def test_crs_to_json_dict():
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
json_dict = aeqd_crs.to_json_dict()
assert json_dict["type"] == "ProjectedCRS"
def test_crs_to_json():
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
json_data = aeqd_crs.to_json()
assert "ProjectedCRS" in json_data
assert "\n" not in json_data
def test_crs_to_json__pretty():
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
json_data = aeqd_crs.to_json(pretty=True)
assert "ProjectedCRS" in json_data
assert json_data.startswith('{\n "')
def test_crs_to_json__pretty__indenation():
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
json_data = aeqd_crs.to_json(pretty=True, indentation=4)
assert "ProjectedCRS" in json_data
assert json_data.startswith('{\n "')
def test_crs_from_json():
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
assert CRS.from_json(aeqd_crs.to_json()) == aeqd_crs
def test_crs_from_json_dict():
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
assert CRS.from_json_dict(aeqd_crs.to_json_dict()) == aeqd_crs
@pytest.mark.parametrize(
"property_name, expected_type",
[
("coordinate_operation", "Conversion"),
("datum", "GeodeticReferenceFrame"),
("ellipsoid", "Ellipsoid"),
("prime_meridian", "PrimeMeridian"),
("coordinate_system", "CoordinateSystem"),
],
)
def test_properties_to_json(property_name, expected_type):
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
json_data = getattr(aeqd_crs, property_name).to_json()
assert expected_type in json_data
assert "\n" not in json_data
@pytest.mark.parametrize(
"property_name, expected_type",
[
("coordinate_operation", "Conversion"),
("datum", "GeodeticReferenceFrame"),
("ellipsoid", "Ellipsoid"),
("prime_meridian", "PrimeMeridian"),
("coordinate_system", "CoordinateSystem"),
],
)
def test_properties_to_json__pretty(property_name, expected_type):
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
json_data = getattr(aeqd_crs, property_name).to_json(pretty=True)
assert expected_type in json_data
assert json_data.startswith('{\n "')
@pytest.mark.parametrize(
"property_name, expected_type",
[
("coordinate_operation", "Conversion"),
("datum", "GeodeticReferenceFrame"),
("ellipsoid", "Ellipsoid"),
("prime_meridian", "PrimeMeridian"),
("coordinate_system", "CoordinateSystem"),
],
)
def test_properties_to_json__pretty__indentation(property_name, expected_type):
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
json_data = getattr(aeqd_crs, property_name).to_json(pretty=True, indentation=4)
assert expected_type in json_data
assert json_data.startswith('{\n "')
@pytest.mark.parametrize(
"property_name, expected_type",
[
("coordinate_operation", "Conversion"),
("datum", "GeodeticReferenceFrame"),
("ellipsoid", "Ellipsoid"),
("prime_meridian", "PrimeMeridian"),
],
)
def test_properties_to_json_dict(property_name, expected_type):
aeqd_crs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5)
assert getattr(aeqd_crs, property_name).to_json_dict()["type"] == expected_type
@pytest.mark.parametrize(
"property_name, init_class",
[
("coordinate_operation", CoordinateOperation),
("datum", Datum),
("ellipsoid", Ellipsoid),
("prime_meridian", PrimeMeridian),
],
)
def test_properties_from_json_dict(property_name, init_class):
prop = getattr(CRS.from_epsg(26915), property_name)
assert init_class.from_json_dict(prop.to_json_dict()) == prop
def test_coordinate_system_from_json_dict():
# separate test from other properties due to
# https://github.com/OSGeo/PROJ/issues/1818
aeqd_cs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5).coordinate_system
assert CoordinateSystem.from_json_dict(aeqd_cs.to_json_dict()) == aeqd_cs
def test_coordinate_system_from_json():
# separate test from other properties due to
# https://github.com/OSGeo/PROJ/issues/1818
aeqd_cs = CRS(proj="aeqd", lon_0=-80, lat_0=40.5).coordinate_system
assert CoordinateSystem.from_json(aeqd_cs.to_json()) == aeqd_cs
pyproj-3.6.1/test/crs/test_crs_maker.py 0000664 0000000 0000000 00000027733 14502715416 0020212 0 ustar 00root root 0000000 0000000 import pytest
from pyproj.crs import (
CRS,
BoundCRS,
CompoundCRS,
CustomConstructorCRS,
DerivedGeographicCRS,
GeocentricCRS,
GeographicCRS,
ProjectedCRS,
VerticalCRS,
)
from pyproj.crs.coordinate_operation import (
AlbersEqualAreaConversion,
LambertConformalConic2SPConversion,
RotatedLatitudeLongitudeConversion,
ToWGS84Transformation,
TransverseMercatorConversion,
UTMConversion,
)
from pyproj.crs.coordinate_system import Cartesian2DCS, Ellipsoidal3DCS, VerticalCS
from pyproj.crs.datum import CustomDatum
from pyproj.crs.enums import VerticalCSAxis
from pyproj.exceptions import CRSError
from test.conftest import PROJ_GTE_901, assert_can_pickle
def assert_maker_inheritance_valid(new_crs, class_type):
assert isinstance(new_crs, class_type)
assert isinstance(new_crs.geodetic_crs, (type(None), CRS))
assert isinstance(new_crs.source_crs, (type(None), CRS))
assert isinstance(new_crs.target_crs, (type(None), CRS))
assert isinstance(new_crs.to_3d(), CRS)
for sub_crs in new_crs.sub_crs_list:
assert isinstance(sub_crs, CRS)
def test_make_projected_crs(tmp_path):
aeaop = AlbersEqualAreaConversion(0, 0)
pc = ProjectedCRS(conversion=aeaop, name="Albers")
assert pc.name == "Albers"
assert pc.type_name == "Projected CRS"
assert pc.coordinate_operation == aeaop
assert_can_pickle(pc, tmp_path)
def test_projected_crs__from_methods():
assert_maker_inheritance_valid(ProjectedCRS.from_epsg(6933), ProjectedCRS)
assert_maker_inheritance_valid(ProjectedCRS.from_string("EPSG:6933"), ProjectedCRS)
assert_maker_inheritance_valid(
ProjectedCRS.from_proj4("+proj=aea +lat_1=1"), ProjectedCRS
)
assert_maker_inheritance_valid(
ProjectedCRS.from_user_input(ProjectedCRS.from_string("EPSG:6933")),
ProjectedCRS,
)
assert_maker_inheritance_valid(
ProjectedCRS.from_json(CRS(6933).to_json()), ProjectedCRS
)
assert_maker_inheritance_valid(
ProjectedCRS.from_json_dict(CRS(6933).to_json_dict()), ProjectedCRS
)
with pytest.raises(CRSError, match="Invalid type"):
ProjectedCRS.from_epsg(4326)
def test_make_geographic_crs(tmp_path):
gc = GeographicCRS(name="WGS 84")
assert gc.name == "WGS 84"
assert gc.type_name == "Geographic 2D CRS"
assert gc.to_authority() == ("OGC", "CRS84")
assert_can_pickle(gc, tmp_path)
def test_geographic_crs__from_methods():
assert_maker_inheritance_valid(GeographicCRS.from_epsg(4326), GeographicCRS)
assert_maker_inheritance_valid(
GeographicCRS.from_string("EPSG:4326"), GeographicCRS
)
assert_maker_inheritance_valid(
GeographicCRS.from_proj4("+proj=latlon"), GeographicCRS
)
assert_maker_inheritance_valid(
GeographicCRS.from_user_input(GeographicCRS.from_string("EPSG:4326")),
GeographicCRS,
)
assert_maker_inheritance_valid(
GeographicCRS.from_json(CRS(4326).to_json()), GeographicCRS
)
assert_maker_inheritance_valid(
GeographicCRS.from_json_dict(CRS(4326).to_json_dict()), GeographicCRS
)
with pytest.raises(CRSError, match="Invalid type"):
GeographicCRS.from_epsg(6933)
def test_make_geographic_3d_crs():
gcrs = GeographicCRS(ellipsoidal_cs=Ellipsoidal3DCS())
assert gcrs.type_name == "Geographic 3D CRS"
expected_authority = ("IGNF", "WGS84GEODD")
if PROJ_GTE_901:
expected_authority = ("OGC", "CRS84h")
assert gcrs.to_authority() == expected_authority
def test_make_derived_geographic_crs(tmp_path):
conversion = RotatedLatitudeLongitudeConversion(o_lat_p=0, o_lon_p=0)
dgc = DerivedGeographicCRS(base_crs=GeographicCRS(), conversion=conversion)
assert dgc.name == "undefined"
assert dgc.type_name == "Derived Geographic 2D CRS"
assert dgc.coordinate_operation == conversion
assert dgc.is_derived
assert_can_pickle(dgc, tmp_path)
def test_derived_geographic_crs__from_methods():
crs_str = "+proj=ob_tran +o_proj=longlat +o_lat_p=0 +o_lon_p=0 +lon_0=0"
with pytest.raises(CRSError, match="Invalid type Geographic 2D CRS"):
DerivedGeographicCRS.from_epsg(4326)
assert_maker_inheritance_valid(
DerivedGeographicCRS.from_string(crs_str), DerivedGeographicCRS
)
assert_maker_inheritance_valid(
DerivedGeographicCRS.from_proj4(crs_str), DerivedGeographicCRS
)
assert_maker_inheritance_valid(
DerivedGeographicCRS.from_user_input(DerivedGeographicCRS.from_string(crs_str)),
DerivedGeographicCRS,
)
assert_maker_inheritance_valid(
DerivedGeographicCRS.from_json(CRS(crs_str).to_json()), DerivedGeographicCRS
)
assert_maker_inheritance_valid(
DerivedGeographicCRS.from_json_dict(CRS(crs_str).to_json_dict()),
DerivedGeographicCRS,
)
def test_make_geocentric_crs(tmp_path):
gc = GeocentricCRS(name="WGS 84")
assert gc.name == "WGS 84"
assert gc.is_geocentric
assert gc.type_name == "Geocentric CRS"
assert gc.to_authority() == ("EPSG", "4978")
assert_can_pickle(gc, tmp_path)
def test_geocentric_crs__from_methods():
assert_maker_inheritance_valid(GeocentricCRS.from_epsg(4978), GeocentricCRS)
assert_maker_inheritance_valid(
GeocentricCRS.from_string("EPSG:4978"), GeocentricCRS
)
assert_maker_inheritance_valid(
GeocentricCRS.from_proj4("+proj=geocent"), GeocentricCRS
)
assert_maker_inheritance_valid(
GeocentricCRS.from_user_input(GeocentricCRS.from_string("EPSG:4978")),
GeocentricCRS,
)
assert_maker_inheritance_valid(
GeocentricCRS.from_json(CRS(4978).to_json()), GeocentricCRS
)
assert_maker_inheritance_valid(
GeocentricCRS.from_json_dict(CRS(4978).to_json_dict()), GeocentricCRS
)
with pytest.raises(CRSError, match="Invalid type"):
GeocentricCRS.from_epsg(6933)
def test_vertical_crs(tmp_path):
vc = VerticalCRS(
name="NAVD88 height",
datum="North American Vertical Datum 1988",
geoid_model="GEOID12B",
)
assert vc.name == "NAVD88 height"
assert vc.type_name == "Vertical CRS"
assert vc.coordinate_system == VerticalCS()
assert vc.to_json_dict()["geoid_model"]["name"] == "GEOID12B"
assert_can_pickle(vc, tmp_path)
def test_vertical_crs__from_methods():
assert_maker_inheritance_valid(VerticalCRS.from_epsg(5703), VerticalCRS)
assert_maker_inheritance_valid(VerticalCRS.from_string("EPSG:5703"), VerticalCRS)
with pytest.raises(CRSError, match="Invalid type"):
VerticalCRS.from_proj4("+proj=latlon")
assert_maker_inheritance_valid(
VerticalCRS.from_user_input(VerticalCRS.from_string("EPSG:5703")), VerticalCRS
)
assert_maker_inheritance_valid(
VerticalCRS.from_json(CRS(5703).to_json()), VerticalCRS
)
assert_maker_inheritance_valid(
VerticalCRS.from_json_dict(CRS(5703).to_json_dict()), VerticalCRS
)
@pytest.mark.parametrize(
"axis",
[
VerticalCSAxis.UP,
VerticalCSAxis.UP_FT,
VerticalCSAxis.DEPTH,
VerticalCSAxis.DEPTH_FT,
VerticalCSAxis.GRAVITY_HEIGHT_FT,
],
)
def test_vertical_crs__chance_cs_axis(axis):
vc = VerticalCRS(
name="NAVD88 height",
datum="North American Vertical Datum 1988",
vertical_cs=VerticalCS(axis=axis),
)
assert vc.name == "NAVD88 height"
assert vc.type_name == "Vertical CRS"
assert vc.coordinate_system == VerticalCS(axis=axis)
def test_compund_crs(tmp_path):
vertcrs = VerticalCRS(
name="NAVD88 height",
datum="North American Vertical Datum 1988",
vertical_cs=VerticalCS(),
geoid_model="GEOID12B",
)
projcrs = ProjectedCRS(
name="NAD83 / Pennsylvania South",
conversion=LambertConformalConic2SPConversion(
latitude_false_origin=39.3333333333333,
longitude_false_origin=-77.75,
latitude_first_parallel=40.9666666666667,
latitude_second_parallel=39.9333333333333,
easting_false_origin=600000,
northing_false_origin=0,
),
geodetic_crs=GeographicCRS(datum="North American Datum 1983"),
cartesian_cs=Cartesian2DCS(),
)
compcrs = CompoundCRS(
name="NAD83 / Pennsylvania South + NAVD88 height", components=[projcrs, vertcrs]
)
assert compcrs.name == "NAD83 / Pennsylvania South + NAVD88 height"
assert compcrs.type_name == "Compound CRS"
assert compcrs.sub_crs_list[0].type_name == "Projected CRS"
assert compcrs.sub_crs_list[1].type_name == "Vertical CRS"
assert_can_pickle(compcrs, tmp_path)
def test_compund_crs__from_methods():
crs = CompoundCRS.from_string("EPSG:4326+5773")
with pytest.raises(CRSError, match="Invalid type"):
CompoundCRS.from_epsg(4326)
assert_maker_inheritance_valid(crs, CompoundCRS)
with pytest.raises(CRSError, match="Invalid type"):
CompoundCRS.from_proj4("+proj=longlat +datum=WGS84 +vunits=m")
assert_maker_inheritance_valid(CompoundCRS.from_user_input(crs), CompoundCRS)
assert_maker_inheritance_valid(CompoundCRS.from_json(crs.to_json()), CompoundCRS)
assert_maker_inheritance_valid(
CompoundCRS.from_json_dict(crs.to_json_dict()), CompoundCRS
)
def test_bound_crs(tmp_path):
proj_crs = ProjectedCRS(conversion=UTMConversion(12))
bound_crs = BoundCRS(
source_crs=proj_crs,
target_crs="WGS 84",
transformation=ToWGS84Transformation(
proj_crs.geodetic_crs, 1, 2, 3, 4, 5, 6, 7
),
)
assert bound_crs.type_name == "Bound CRS"
assert bound_crs.source_crs.coordinate_operation.name == "UTM zone 12N"
assert bound_crs.coordinate_operation.towgs84 == [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]
assert bound_crs.target_crs.name == "WGS 84"
assert_can_pickle(bound_crs, tmp_path)
def test_bound_crs__example():
proj_crs = ProjectedCRS(
conversion=TransverseMercatorConversion(
latitude_natural_origin=0,
longitude_natural_origin=15,
false_easting=2520000,
false_northing=0,
scale_factor_natural_origin=0.9996,
),
geodetic_crs=GeographicCRS(
datum=CustomDatum(ellipsoid="International 1924 (Hayford 1909, 1910)")
),
)
bound_crs = BoundCRS(
source_crs=proj_crs,
target_crs="WGS 84",
transformation=ToWGS84Transformation(
proj_crs.geodetic_crs, -122.74, -34.27, -22.83, -1.884, -3.4, -3.03, -15.62
),
)
with pytest.warns(UserWarning):
assert bound_crs.to_dict() == {
"ellps": "intl",
"k": 0.9996,
"lat_0": 0,
"lon_0": 15,
"no_defs": None,
"proj": "tmerc",
"towgs84": [-122.74, -34.27, -22.83, -1.884, -3.4, -3.03, -15.62],
"type": "crs",
"units": "m",
"x_0": 2520000,
"y_0": 0,
}
def test_bound_crs_crs__from_methods():
crs_str = "+proj=latlon +towgs84=0,0,0"
with pytest.raises(CRSError, match="Invalid type"):
BoundCRS.from_epsg(4326)
assert_maker_inheritance_valid(BoundCRS.from_string(crs_str), BoundCRS)
assert_maker_inheritance_valid(BoundCRS.from_proj4(crs_str), BoundCRS)
assert_maker_inheritance_valid(
BoundCRS.from_user_input(BoundCRS.from_string(crs_str)), BoundCRS
)
assert_maker_inheritance_valid(BoundCRS.from_json(CRS(crs_str).to_json()), BoundCRS)
assert_maker_inheritance_valid(
BoundCRS.from_json_dict(CRS(crs_str).to_json_dict()), BoundCRS
)
def test_custom_constructor_crs__not_implemented():
class MyCustomInit(CustomConstructorCRS):
def __init__(self, *, name: str):
super().__init__(name)
with pytest.raises(NotImplementedError):
MyCustomInit.from_epsg(4326)
def test_custom_constructor_crs():
class MyCustomInit(CustomConstructorCRS):
_expected_types = ("Geographic 2D CRS",)
def __init__(self, *, name: str):
super().__init__(name)
assert isinstance(MyCustomInit.from_epsg(4326), MyCustomInit)
pyproj-3.6.1/test/sample.out 0000664 0000000 0000000 00000007117 14502715416 0016050 0 ustar 00root root 0000000 0000000 output of test.py
=================
proj4 library version = 4.49
4 crnrs of AWIPS grid 221:
-145.5 0.99999999999
-68.3182659527 0.896932791646
-2.5660073938 46.352013053
148.638612551 46.6347160116
from GRIB docs
(see http://www.nco.ncep.noaa.gov/pmb/docs/on388/tableb.html)
-145.5 1.0
-68.318 0.897
-2.566 46.352
148.639 46.635
data in lists:
compute lats/lons for all points on AWIPS 221 grid (349x277)
max/min lons
-179.998717833 179.99098295
max/min lats
0.896932791646 85.3340424275
took 0.19 secs
data in python arrays:
compute lats/lons for all points on AWIPS 221 grid (349x277)
max/min lons
-179.998715866 179.990981756
max/min lats
0.896931758891 85.3340414374
took 0.14 secs
data in a Numeric/numarray array:
compute lats/lons for all points on AWIPS 221 grid (349x277)
max/min lons
-179.998717833 179.99098295
max/min lats
0.896932791646 85.3340424275
took 0.07 secs
max abs error for x
6.78119249642e-09
max abs error for y
6.78119249642e-09
took 0.07 secs
compare output with sample.out
now run test2.py to test pickling
output of test2.py
==================
do it again, from pickled instance ...
compute lats/lons for all points on AWIPS 221 grid (349x277)
max/min lons in radians
-3.14157024122 3.14143525553
max/min lats in radians
0.0156544123584 1.48935998712
took 0.08 secs
max abs error for x
6.83576217853e-09
max abs error for y
9.31322574615e-09
took 0.06 secs
output of test_transform.py
===========================
proj4 library version = 4.49
(-4.9489738955799112e-06, 4.5528711254405607e-06) (should be close to zero)
(-3.203692330089325e-06, 1.8227847107255002e-06) (should close to zero)
max/min x and y for awips218 grid
0.0 7472825.54
0.0 5205377.66
max/min x and y for awips218 grid in awips221 coordinates
2224130.9457 10705426.2541
673840.639255 6706800.54439
error for reverse transformation back to awips218 coords
(should be close to zero)
-4.88944351673e-09 5.58793544769e-09
-9.72067937255e-09 1.04773789644e-08
output of datum_shift.py
========================
proj4 library version = 4.49
WGS84-->UTM
Trieste, Molo Sartorio WGS84: 13.759554722 45.647188611 52.799999999999997
Trieste, Molo Sartorio UTM33 (from IGM): 403340.97 5055597.17
Trieste, Molo Sartorio UTM33 (converted): 403340.96723675972 5055597.1755538993 52.799999999999997
Difference (meters): -0.0027632402488961816 0.0055538993328809738 0.0
WGS84-->Gauss-Boaga
Trieste, Molo Sartorio Gauss-Boaga (from IGM): 2423346.99 5055619.87
Trieste, Molo Sartorio Gauss-Boaga (converted): 2423346.9950080249 5055619.899023423
Difference (meters): 0.0050080246292054653 0.029023422859609127
UTM-->WGS84
Trieste, Molo Sartorio UTM33 (converted): 403340.96723675972 5055597.1755538993 52.799999999999997
Trieste, Molo Sartorio WGS84 (converted back): 13.759554722 45.647188611 52.799999999999997
Difference (seconds): -1.18305365504e-09 -1.20223830891e-09 0.0 (m)
Gauss-Boaga-->WGS84
Trieste, Molo Sartorio Gauss-Boaga (converted): 2423346.9950080249 5055619.899023423 0.1668358146915066
Trieste, Molo Sartorio WGS84 (converted back): 13.7595547 45.6471886096 0.0012277923978516671
Difference (seconds): -7.91165149394e-05 -4.8976630751e-06 -52.798772207602148 (m)
UTM (from IGM) --> WGS84
Trieste, Molo Sartorio UTM33 (from IGM): 403340.97 5055597.17
Trieste, Molo Sartorio WGS84 (converted): 13.7595547586 45.6471885614 52.799999999999997
Difference (seconds): 0.000131600918962 -0.000178537351303 0.0 (m)
Gauss-Boaga (from IGM) --> WGS84
Trieste, Molo Sartorio Gauss-Boaga (from IGM): 2423346.99 5055619.87
Trieste, Molo Sartorio WGS84 (converted): 13.7595546415 45.6471883478
Difference (seconds): -0.000289702808942 -0.00094763802565
pyproj-3.6.1/test/test_aoi.py 0000664 0000000 0000000 00000002202 14502715416 0016205 0 ustar 00root root 0000000 0000000 import pytest
from pyproj.aoi import AreaOfInterest, BBox
def test_backwards_compatible_import_paths():
from pyproj.transformer import ( # noqa: F401 pylint: disable=unused-import
AreaOfInterest,
)
def test_contains():
assert BBox(1, 1, 4, 4).contains(BBox(2, 2, 3, 3))
def test_not_contains():
assert not BBox(1, 1, 4, 4).contains(BBox(2, 2, 5, 5))
def test_intersects():
assert BBox(1, 1, 4, 4).intersects(BBox(2, 2, 5, 5))
def test_not_intersects():
assert not BBox(1, 1, 4, 4).intersects(BBox(10, 10, 20, 20))
@pytest.mark.parametrize("aoi_class", [AreaOfInterest, BBox])
@pytest.mark.parametrize(
"input",
[
(None, None, None, None),
(float("nan"), float("nan"), float("nan"), float("nan")),
(None, 0, 0, 0),
(float("nan"), 0, 0, 0),
(0, None, 0, 0),
(0, float("nan"), 0, 0),
(0, 0, None, 0),
(0, 0, float("nan"), 0),
(0, 0, 0, None),
(0, 0, 0, float("nan")),
],
)
def test_null_input(aoi_class, input):
with pytest.raises(ValueError, match="NaN or None values are not allowed."):
aoi_class(*input)
pyproj-3.6.1/test/test_awips221.py 0000664 0000000 0000000 00000007721 14502715416 0017020 0 ustar 00root root 0000000 0000000 import array
import numpy
from numpy.testing import assert_allclose
from pyproj import Proj, __proj_version__
try:
from time import perf_counter
except ImportError:
from time import clock as perf_counter
def test_awips221():
params = {}
params["proj"] = "lcc"
params["R"] = 6371200
params["lat_1"] = 50
params["lat_2"] = 50
params["lon_0"] = -107
nx = 349
ny = 277
dx = 32463.41
dy = dx
# can either use a dict
# awips221 = Proj(params)
# or keyword args
awips221 = Proj(proj="lcc", R=6371200, lat_1=50, lat_2=50, lon_0=-107)
print("proj4 library version = ", __proj_version__)
# AWIPS grid 221 parameters
# (from http://www.nco.ncep.noaa.gov/pmb/docs/on388/tableb.html)
llcrnrx, llcrnry = awips221(-145.5, 1.0)
params["x_0"] = -llcrnrx
params["y_0"] = -llcrnry
awips221 = Proj(params)
llcrnrx, llcrnry = awips221(-145.5, 1.0)
# find 4 lon/lat crnrs of AWIPS grid 221.
llcrnrx = 0.0
llcrnry = 0.0
lrcrnrx = dx * (nx - 1)
lrcrnry = 0.0
ulcrnrx = 0.0
ulcrnry = dy * (ny - 1)
urcrnrx = dx * (nx - 1)
urcrnry = dy * (ny - 1)
llcrnrlon, llcrnrlat = awips221(llcrnrx, llcrnry, inverse=True)
lrcrnrlon, lrcrnrlat = awips221(lrcrnrx, lrcrnry, inverse=True)
urcrnrlon, urcrnrlat = awips221(urcrnrx, urcrnry, inverse=True)
ulcrnrlon, ulcrnrlat = awips221(ulcrnrx, ulcrnry, inverse=True)
print("4 crnrs of AWIPS grid 221:")
print(llcrnrlon, llcrnrlat)
print(lrcrnrlon, lrcrnrlat)
print(urcrnrlon, urcrnrlat)
print(ulcrnrlon, ulcrnrlat)
print("from GRIB docs")
print("(see http://www.nco.ncep.noaa.gov/pmb/docs/on388/tableb.html)")
print(" -145.5 1.0")
print(" -68.318 0.897")
print(" -2.566 46.352")
print(" 148.639 46.635")
# compute lons and lats for the whole AWIPS grid 221 (377x249).
dx = (urcrnrx - llcrnrx) / (nx - 1)
dy = (urcrnry - llcrnry) / (ny - 1)
x = llcrnrx + dx * numpy.indices((ny, nx), "f")[1, :, :]
y = llcrnry + dy * numpy.indices((ny, nx), "f")[0, :, :]
t1 = perf_counter()
lons, lats = awips221(
numpy.ravel(x).tolist(), numpy.ravel(y).tolist(), inverse=True
)
t2 = perf_counter()
print("data in lists:")
print("compute lats/lons for all points on AWIPS 221 grid ({}x{})".format(nx, ny))
print("max/min lons")
print(min(lons), max(lons))
print("max/min lats")
print(min(lats), max(lats))
print("took", t2 - t1, "secs")
xa = array.array("f", numpy.ravel(x).tolist())
ya = array.array("f", numpy.ravel(y).tolist())
t1 = perf_counter()
lons, lats = awips221(xa, ya, inverse=True)
t2 = perf_counter()
print("data in python arrays:")
print("compute lats/lons for all points on AWIPS 221 grid ({}x{})".format(nx, ny))
print("max/min lons")
print(min(lons), max(lons))
print("max/min lats")
print(min(lats), max(lats))
print("took", t2 - t1, "secs")
t1 = perf_counter()
lons, lats = awips221(x, y, inverse=True)
t2 = perf_counter()
print("data in a numpy array:")
print("compute lats/lons for all points on AWIPS 221 grid ({}x{})".format(nx, ny))
print("max/min lons")
print(
numpy.minimum.reduce(numpy.ravel(lons)), numpy.maximum.reduce(numpy.ravel(lons))
)
print("max/min lats")
print(
numpy.minimum.reduce(numpy.ravel(lats)), numpy.maximum.reduce(numpy.ravel(lats))
)
print("took", t2 - t1, "secs")
# reverse transformation.
t1 = perf_counter()
xx, yy = awips221(lons, lats)
t2 = perf_counter()
print("max abs error for x")
max_abs_err_x = numpy.maximum.reduce(numpy.fabs(numpy.ravel(x - xx)))
print(max_abs_err_x)
assert_allclose(max_abs_err_x, 0, atol=1e-4)
print("max abs error for y")
max_abs_err_y = numpy.maximum.reduce(numpy.fabs(numpy.ravel(y - yy)))
print(max_abs_err_y)
assert_allclose(max_abs_err_y, 0, atol=1e-4)
print("took", t2 - t1, "secs")
print("compare output with sample.out")
pyproj-3.6.1/test/test_cli.py 0000664 0000000 0000000 00000024551 14502715416 0016217 0 ustar 00root root 0000000 0000000 import argparse
import os
import subprocess
import sys
from glob import glob
from pathlib import Path
from unittest.mock import patch
import pytest
from pyproj.__main__ import main
from pyproj.datadir import append_data_dir, get_data_dir, get_user_data_dir
from pyproj.sync import _load_grid_geojson
from test.conftest import grids_available, proj_env, tmp_chdir
PYPROJ_CLI_ENDPONTS = pytest.mark.parametrize(
"input_command", [["pyproj"], [sys.executable, "-m", "pyproj"]]
)
@pytest.mark.cli
@PYPROJ_CLI_ENDPONTS
def test_main(input_command, tmpdir):
with tmp_chdir(str(tmpdir)):
output = subprocess.check_output(
input_command, stderr=subprocess.STDOUT
).decode("utf-8")
assert "pyproj version:" in output
assert "PROJ version:" in output
assert "-v, --verbose Show verbose debugging version information." in output
@pytest.mark.cli
@PYPROJ_CLI_ENDPONTS
@pytest.mark.parametrize("option", ["-v", "--verbose"])
def test_main__verbose(input_command, option, tmpdir):
with tmp_chdir(str(tmpdir)):
output = subprocess.check_output(
input_command + [option], stderr=subprocess.STDOUT
).decode("utf-8")
assert "pyproj:" in output
assert "PROJ:" in output
assert "data dir" in output
assert "user_data_dir" in output
assert "System" in output
assert "python" in output
assert "Python deps" in output
assert "-v, --verbose " not in output
@pytest.mark.cli
@PYPROJ_CLI_ENDPONTS
@pytest.mark.parametrize("option", [["-h"], []])
def test_sync(input_command, option, tmpdir):
with tmp_chdir(str(tmpdir)):
output = subprocess.check_output(
input_command + ["sync"] + option, stderr=subprocess.STDOUT
).decode("utf-8")
assert (
"Tool for synchronizing PROJ datum and transformation support data." in output
)
assert "--bbox" in output
assert "--spatial-test" in output
assert "--source-id" in output
assert "--area-of-use" in output
assert "--file" in output
assert "--exclude-world-coverage" in output
assert "--include-already-downloaded" in output
assert "--list-files" in output
assert "--system-directory" in output
assert "--target-directory" in output
assert "-v, --verbose" in output
def _check_list_files_header(lines):
assert lines[0].rstrip("\r") == "filename | source_id | area_of_use"
assert lines[1].rstrip("\r") == "----------------------------------"
@pytest.mark.cli
@pytest.mark.network
@PYPROJ_CLI_ENDPONTS
def test_sync__source_id__list(input_command, tmpdir):
with tmp_chdir(str(tmpdir)):
output = subprocess.check_output(
input_command
+ [
"sync",
"--source-id",
"fr_ign",
"--list-files",
"--include-already-downloaded",
],
stderr=subprocess.STDOUT,
).decode("utf-8")
lines = output.strip().split("\n")
assert len(lines) > 2
_check_list_files_header(lines)
for line in lines[2:]:
assert "fr_ign" == line.split("|")[1].strip()
@pytest.mark.cli
@pytest.mark.network
@PYPROJ_CLI_ENDPONTS
def test_sync__area_of_use__list(input_command, tmpdir):
with tmp_chdir(str(tmpdir)):
output = subprocess.check_output(
input_command
+ [
"sync",
"--area-of-use",
"France",
"--list-files",
"--include-already-downloaded",
],
stderr=subprocess.STDOUT,
).decode("utf-8")
lines = output.strip().split("\n")
assert len(lines) > 2
_check_list_files_header(lines)
for line in lines[2:]:
assert "France" in line.split("|")[-1]
@pytest.mark.cli
@pytest.mark.network
@PYPROJ_CLI_ENDPONTS
def test_sync__file__list(input_command, tmpdir):
with tmp_chdir(str(tmpdir)):
output = subprocess.check_output(
input_command
+ [
"sync",
"--file",
"ntf_r93",
"--list-files",
"--include-already-downloaded",
],
stderr=subprocess.STDOUT,
).decode("utf-8")
lines = output.strip().split("\n")
assert len(lines) > 2
_check_list_files_header(lines)
for line in lines[2:]:
assert "ntf_r93" in line.split("|")[0]
@pytest.mark.cli
@pytest.mark.network
@PYPROJ_CLI_ENDPONTS
def test_sync__bbox__list(input_command, tmpdir):
with tmp_chdir(str(tmpdir)):
output = subprocess.check_output(
input_command
+ [
"sync",
"--bbox",
"2,49,3,50",
"--list-files",
"--include-already-downloaded",
],
stderr=subprocess.STDOUT,
).decode("utf-8")
lines = output.strip().split("\n")
assert len(lines) > 2
_check_list_files_header(lines)
assert " | be_ign | " in output
assert " | us_nga | " in output
assert " | fr_ign | " in output
@pytest.mark.cli
@pytest.mark.network
@PYPROJ_CLI_ENDPONTS
def test_sync__bbox__list__exclude_world_coverage(input_command, tmpdir):
with tmp_chdir(str(tmpdir)):
output = subprocess.check_output(
input_command
+ [
"sync",
"--bbox",
"2,49,3,50",
"--exclude-world-coverage",
"--list-files",
"--include-already-downloaded",
],
stderr=subprocess.STDOUT,
).decode("utf-8")
lines = output.strip().split("\n")
assert len(lines) > 2
_check_list_files_header(lines)
assert " | be_ign | " in output
assert " | us_nga | " not in output
assert " | fr_ign | " in output
@pytest.mark.cli
@PYPROJ_CLI_ENDPONTS
@pytest.mark.parametrize(
"extra_arg",
[
"--list-files",
"--source-id",
"--area-of-use",
"--bbox",
"--list-files",
"--file",
],
)
def test_sync__all__exclusive_error(input_command, extra_arg, tmpdir):
with tmp_chdir(str(tmpdir)), pytest.raises(subprocess.CalledProcessError):
subprocess.check_output(
input_command + ["sync", "--all", extra_arg], stderr=subprocess.STDOUT
)
@pytest.mark.network
@patch(
"pyproj.__main__.parser.parse_args",
return_value=argparse.Namespace(
bbox=None,
list_files=False,
file="ntf_r93",
all=False,
source_id=None,
area_of_use=None,
verbose=False,
target_directory=None,
system_directory=False,
spatial_test="intersects",
exclude_world_coverage=False,
include_already_downloaded=True,
),
)
@patch("pyproj.__main__._download_resource_file")
def test_sync_download(download_mock, parse_args_mock):
main()
download_mock.assert_called_with(
directory=get_user_data_dir(),
file_url="https://cdn.proj.org/fr_ign_ntf_r93.tif",
sha256="0aa738b3e00fd2d64f8e3cd0e76034d4792374624fa0e133922433c9491bbf2a",
short_name="fr_ign_ntf_r93.tif",
verbose=False,
)
@pytest.mark.network
@patch(
"pyproj.__main__.parser.parse_args",
return_value=argparse.Namespace(
bbox=None,
list_files=False,
file="ntf_r93",
all=False,
source_id=None,
area_of_use=None,
verbose=True,
target_directory="test_directory",
system_directory=False,
spatial_test="intersects",
exclude_world_coverage=False,
include_already_downloaded=True,
),
)
@patch("pyproj.__main__._download_resource_file")
@patch("pyproj.sync._load_grid_geojson")
def test_sync_download__directory(
load_grid_geojson_mock, download_mock, parse_args_mock
):
load_grid_geojson_mock.return_value = _load_grid_geojson()
main()
download_mock.assert_called_with(
directory="test_directory",
file_url="https://cdn.proj.org/fr_ign_ntf_r93.tif",
sha256="0aa738b3e00fd2d64f8e3cd0e76034d4792374624fa0e133922433c9491bbf2a",
short_name="fr_ign_ntf_r93.tif",
verbose=True,
)
load_grid_geojson_mock.assert_called_with(target_directory="test_directory")
@pytest.mark.network
@patch(
"pyproj.__main__.parser.parse_args",
return_value=argparse.Namespace(
bbox=None,
list_files=False,
file="ntf_r93",
all=False,
source_id=None,
area_of_use=None,
verbose=True,
target_directory=None,
system_directory=True,
spatial_test="intersects",
exclude_world_coverage=False,
include_already_downloaded=True,
),
)
@patch("pyproj.__main__._download_resource_file")
@patch("pyproj.sync._load_grid_geojson")
def test_sync_download__system_directory(
load_grid_geojson_mock, download_mock, parse_args_mock
):
load_grid_geojson_mock.return_value = _load_grid_geojson()
main()
datadir = get_data_dir().split(os.path.sep)[0]
download_mock.assert_called_with(
directory=datadir,
file_url="https://cdn.proj.org/fr_ign_ntf_r93.tif",
sha256="0aa738b3e00fd2d64f8e3cd0e76034d4792374624fa0e133922433c9491bbf2a",
short_name="fr_ign_ntf_r93.tif",
verbose=True,
)
load_grid_geojson_mock.assert_called_with(target_directory=datadir)
@pytest.mark.network
@patch("pyproj.__main__.parser.parse_args")
def test_sync__download_grids(parse_args_mock, tmp_path, capsys):
parse_args_mock.return_value = argparse.Namespace(
bbox=None,
list_files=False,
file="us_noaa_alaska",
all=False,
source_id=None,
area_of_use=None,
verbose=True,
target_directory=str(tmp_path),
system_directory=False,
spatial_test="intersects",
exclude_world_coverage=False,
include_already_downloaded=False,
)
main()
captured = capsys.readouterr()
paths = sorted(Path(path).name for path in glob(str(tmp_path.joinpath("*"))))
if grids_available("us_noaa_alaska.tif", check_network=False):
assert paths == ["files.geojson"]
assert captured.out == ""
else:
assert paths == ["files.geojson", "us_noaa_alaska.tif"]
assert captured.out == "Downloading: https://cdn.proj.org/us_noaa_alaska.tif\n"
# make sure not downloaded again
with proj_env():
append_data_dir(str(tmp_path))
main()
captured = capsys.readouterr()
assert captured.out == ""
pyproj-3.6.1/test/test_database.py 0000664 0000000 0000000 00000020534 14502715416 0017211 0 ustar 00root root 0000000 0000000 import pytest
from pyproj.aoi import AreaOfInterest, BBox
from pyproj.database import (
Unit,
get_authorities,
get_codes,
get_database_metadata,
get_units_map,
query_crs_info,
query_utm_crs_info,
)
from pyproj.enums import PJType
from test.conftest import PROJ_GTE_92
def test_backwards_compatible_import_paths():
from pyproj import ( # noqa: F401 pylint: disable=unused-import
get_authorities,
get_codes,
get_units_map,
)
def test_units_map__default():
units_map = get_units_map()
assert isinstance(units_map["metre"], Unit)
assert units_map["metre"].name == "metre"
assert units_map["metre"].auth_name == "EPSG"
assert units_map["metre"].code == "9001"
assert units_map["metre"].category == "linear"
assert units_map["metre"].conv_factor == 1
assert units_map["metre"].proj_short_name == "m"
assert not units_map["metre"].deprecated
any_deprecated = False
for item in units_map.values():
any_deprecated = any_deprecated or item.deprecated
assert not any_deprecated
@pytest.mark.parametrize(
"category",
[
"linear",
"linear_per_time",
"angular",
"angular_per_time",
"scale",
"scale_per_time",
"time",
],
)
def test_units_map__category(category):
units_map = get_units_map(category=category)
assert len(units_map) > 1
for item in units_map.values():
assert item.category == category
@pytest.mark.parametrize("auth_name", ["EPSG", "PROJ"])
def test_units_map__auth_name(auth_name):
units_map = get_units_map(auth_name=auth_name)
assert len(units_map) > 1
for item in units_map.values():
assert item.auth_name == auth_name
@pytest.mark.parametrize("deprecated", ["zzz", "True", True])
def test_units_map__deprecated(deprecated):
units_map = get_units_map(allow_deprecated=deprecated)
assert len(units_map) > 1
any_deprecated = False
for item in units_map.values():
any_deprecated = any_deprecated or item.deprecated
assert any_deprecated
@pytest.mark.parametrize("auth_name, category", [(None, 1), (1, None)])
def test_units_map__invalid(auth_name, category):
with pytest.raises(TypeError):
get_units_map(auth_name=auth_name, category=category)
def test_get_authorities():
assert "EPSG" in get_authorities()
@pytest.mark.parametrize(
"auth, pj_type, deprecated",
[
("IGNF", PJType.ELLIPSOID, False),
("EPSG", PJType.CRS, False),
("EPSG", PJType.CRS, True),
("PROJ", PJType.ELLIPSOID, False),
("IGNF", "ELLIPSOID", False),
("EPSG", "CRS", False),
("EPSG", "crs", True),
("PROJ", "ellipsoid", False),
],
)
def test_get_codes(auth, pj_type, deprecated):
assert get_codes(auth, pj_type, deprecated)
@pytest.mark.parametrize(
"auth, pj_type",
[("blob", "BOUND_CRS"), ("PROJ", PJType.BOUND_CRS), ("ITRF", PJType.BOUND_CRS)],
)
def test_get_codes__empty(auth, pj_type):
assert not get_codes(auth, pj_type)
def test_get_codes__derived_projected_crs():
if PROJ_GTE_92:
assert not get_codes("EPSG", PJType.DERIVED_PROJECTED_CRS)
else:
with pytest.raises(
NotImplementedError, match="DERIVED_PROJECTED_CRS requires PROJ 9.2+"
):
get_codes("EPSG", PJType.DERIVED_PROJECTED_CRS)
def test_get_codes__invalid_auth():
with pytest.raises(TypeError):
get_codes(123, PJType.BOUND_CRS)
def test_get_codes__invalid_code():
with pytest.raises(ValueError):
get_codes("ITRF", "frank")
@pytest.mark.parametrize(
"auth, pj_type, deprecated",
[
(None, None, False),
("EPSG", PJType.PROJECTED_CRS, False),
("EPSG", PJType.PROJECTED_CRS, True),
("IGNF", [PJType.GEOGRAPHIC_3D_CRS, PJType.GEOGRAPHIC_2D_CRS], False),
("EPSG", "PROJECTED_CRS", False),
("EPSG", "Projected_Crs", True),
],
)
def test_query_crs_info(auth, pj_type, deprecated):
crs_info_list = query_crs_info(auth, pj_type, allow_deprecated=deprecated)
assert crs_info_list
any_deprecated = any(crs_info.deprecated for crs_info in crs_info_list)
if deprecated:
assert any_deprecated
else:
assert not any_deprecated
def test_query_crs_info__derived_projected_crs():
if PROJ_GTE_92:
assert not query_crs_info(pj_types=PJType.DERIVED_PROJECTED_CRS)
else:
with pytest.raises(
NotImplementedError, match="DERIVED_PROJECTED_CRS requires PROJ 9.2+"
):
query_crs_info(pj_types=PJType.DERIVED_PROJECTED_CRS)
@pytest.mark.parametrize(
"auth, pj_type",
[
("blob", "BOUND_CRS"),
("IGNF", PJType.ELLIPSOID),
("PROJ", PJType.BOUND_CRS),
("ITRF", PJType.BOUND_CRS),
],
)
def test_query_crs_info__empty(auth, pj_type):
assert not query_crs_info(auth, pj_type)
def test_query_crs_info__invalid_auth():
with pytest.raises(TypeError):
query_crs_info(123, PJType.BOUND_CRS)
def test_query_crs_info__invalid_code():
with pytest.raises(ValueError):
query_crs_info("ITRF", "frank")
def test_query_crs_info__aoi():
aoi = BBox(west=-40, south=50, east=-20, north=70)
crs_info_list = query_crs_info(
auth_name="ESRI",
pj_types=PJType.PROJECTED_CRS,
area_of_interest=AreaOfInterest(
west_lon_degree=aoi.west,
south_lat_degree=aoi.south,
east_lon_degree=aoi.east,
north_lat_degree=aoi.north,
),
)
assert crs_info_list
not_contains_present = False
for crs_info in crs_info_list:
bbox = BBox(*crs_info.area_of_use.bounds)
assert bbox.intersects(aoi)
assert crs_info.auth_name == "ESRI"
assert crs_info.type == PJType.PROJECTED_CRS
assert not crs_info.deprecated
if not bbox.contains(aoi):
not_contains_present = True
assert not_contains_present
def test_query_crs_info__aoi_contains():
aoi = BBox(west=-40, south=50, east=-20, north=70)
crs_info_list = query_crs_info(
auth_name="IGNF",
pj_types=[PJType.PROJECTED_CRS],
area_of_interest=AreaOfInterest(
west_lon_degree=aoi.west,
south_lat_degree=aoi.south,
east_lon_degree=aoi.east,
north_lat_degree=aoi.north,
),
contains=True,
)
assert crs_info_list
for crs_info in crs_info_list:
assert BBox(*crs_info.area_of_use.bounds).contains(aoi)
assert crs_info.auth_name == "IGNF"
assert crs_info.type == PJType.PROJECTED_CRS
assert not crs_info.deprecated
@pytest.mark.parametrize("datum_name", ["WGS 84", "WGS84", "NAD27", "NAD83"])
def test_query_utm_crs_info__aoi_datum_name(datum_name):
aoi = BBox(west=-93.581543, south=42.032974, east=-93.581543, north=42.032974)
crs_info_list = query_utm_crs_info(
datum_name=datum_name,
area_of_interest=AreaOfInterest(
west_lon_degree=aoi.west,
south_lat_degree=aoi.south,
east_lon_degree=aoi.east,
north_lat_degree=aoi.north,
),
)
assert len(crs_info_list) == 1
crs_info = crs_info_list[0]
bbox = BBox(*crs_info.area_of_use.bounds)
assert bbox.intersects(aoi)
assert "UTM zone" in crs_info.name
assert datum_name.replace(" ", "") in crs_info.name.replace(" ", "")
assert crs_info.auth_name == "EPSG"
assert crs_info.type == PJType.PROJECTED_CRS
assert not crs_info.deprecated
def test_query_utm_crs_info__aoi_contains():
aoi = BBox(west=41, south=50, east=42, north=51)
crs_info_list = query_utm_crs_info(
area_of_interest=AreaOfInterest(
west_lon_degree=aoi.west,
south_lat_degree=aoi.south,
east_lon_degree=aoi.east,
north_lat_degree=aoi.north,
),
contains=True,
)
assert crs_info_list
for crs_info in crs_info_list:
assert BBox(*crs_info.area_of_use.bounds).contains(aoi)
assert "UTM zone" in crs_info.name
assert crs_info.auth_name == "EPSG"
assert crs_info.type == PJType.PROJECTED_CRS
assert not crs_info.deprecated
def test_get_database_metadata():
epsg_version = get_database_metadata("EPSG.VERSION")
assert epsg_version
assert isinstance(epsg_version, str)
def test_get_database_metadata__invalid():
assert get_database_metadata("doesnotexist") is None
pyproj-3.6.1/test/test_datadir.py 0000664 0000000 0000000 00000023230 14502715416 0017051 0 ustar 00root root 0000000 0000000 import logging
import os
from contextlib import contextmanager
from pathlib import Path
from unittest.mock import patch
import pytest
import pyproj._datadir
from pyproj import CRS, Transformer, get_codes, set_use_global_context
from pyproj._datadir import _pyproj_global_context_initialize
from pyproj.datadir import (
DataDirError,
append_data_dir,
get_data_dir,
get_user_data_dir,
set_data_dir,
)
from pyproj.enums import PJType
from pyproj.exceptions import CRSError
from test.conftest import proj_env
@contextmanager
def proj_context_env():
"""
Ensure setting for global context is the same at the end.
"""
context = pyproj._datadir._USE_GLOBAL_CONTEXT
try:
yield
finally:
pyproj._datadir._USE_GLOBAL_CONTEXT = context
@contextmanager
def proj_logging_env():
"""
Ensure handler is added and then removed at end.
"""
console_handler = logging.StreamHandler()
formatter = logging.Formatter("%(threadName)s:%(levelname)s:%(message)s")
console_handler.setFormatter(formatter)
logger = logging.getLogger("pyproj")
logger.addHandler(console_handler)
logger.setLevel(logging.DEBUG)
try:
yield
finally:
logger.removeHandler(console_handler)
def create_projdb(tmpdir):
Path(tmpdir, "proj.db").write_text("DUMMY proj.db")
_INVALID_PATH = Path("/invalid/path/to/nowhere")
def test_get_data_dir__missing():
with proj_env(), pytest.raises(DataDirError), patch.dict(
os.environ, {}, clear=True
), patch("pyproj.datadir.Path.absolute", return_value=_INVALID_PATH), patch(
"pyproj.datadir.shutil.which", return_value=None
), patch(
"pyproj.datadir.Path.absolute", return_value=_INVALID_PATH
), patch(
"pyproj.datadir.sys.prefix", str(_INVALID_PATH)
):
assert get_data_dir() is None
def test_pyproj_global_context_initialize__datadir_missing():
with proj_env(), pytest.raises(DataDirError), patch(
"pyproj.datadir.get_data_dir", side_effect=DataDirError("test")
):
_pyproj_global_context_initialize()
@pytest.mark.parametrize("projdir_type", [str, Path])
def test_get_data_dir__from_user(projdir_type, tmp_path):
tmpdir = tmp_path / "proj"
tmpdir.mkdir()
tmpdir_env = tmp_path / "proj_env"
tmpdir_env.mkdir()
with proj_env(), patch.dict(
os.environ, {"PROJ_DATA": str(tmpdir_env)}, clear=True
), patch("pyproj.datadir.Path.absolute", return_value=tmpdir / "datadir.py"), patch(
"pyproj.datadir.sys.prefix", str(tmpdir_env)
): # noqa: E501
create_projdb(tmpdir)
create_projdb(tmpdir_env)
set_data_dir(projdir_type(tmpdir))
internal_proj_dir = tmpdir / "proj_dir" / "share" / "proj"
internal_proj_dir.mkdir(parents=True)
create_projdb(internal_proj_dir)
assert get_data_dir() == str(tmpdir)
def test_get_data_dir__internal(tmp_path):
tmpdir = tmp_path / "proj"
tmpdir.mkdir()
tmpdir_fake = tmp_path / "proj_fake"
tmpdir_fake.mkdir()
with proj_env(), patch.dict(
os.environ,
{"PROJ_LIB": str(tmpdir_fake), "PROJ_DATA": str(tmpdir_fake)},
clear=True,
), patch("pyproj.datadir.Path.absolute", return_value=tmpdir / "datadir.py"), patch(
"pyproj.datadir.sys.prefix", str(tmpdir_fake)
):
create_projdb(tmpdir)
create_projdb(tmpdir_fake)
internal_proj_dir = tmpdir / "proj_dir" / "share" / "proj"
internal_proj_dir.mkdir(parents=True)
create_projdb(internal_proj_dir)
assert get_data_dir() == str(internal_proj_dir)
def test_get_data_dir__from_env_var__proj_lib(tmp_path):
with proj_env(), patch.dict(
os.environ, {"PROJ_LIB": str(tmp_path)}, clear=True
), patch("pyproj.datadir.Path.absolute", return_value=_INVALID_PATH), patch(
"pyproj.datadir.sys.prefix", str(_INVALID_PATH)
):
create_projdb(tmp_path)
assert get_data_dir() == str(tmp_path)
def test_get_data_dir__from_env_var__proj_data(tmp_path):
with proj_env(), patch.dict(
os.environ, {"PROJ_DATA": str(tmp_path)}, clear=True
), patch("pyproj.datadir.Path.absolute", return_value=_INVALID_PATH), patch(
"pyproj.datadir.sys.prefix", str(_INVALID_PATH)
):
create_projdb(tmp_path)
assert get_data_dir() == str(tmp_path)
def test_get_data_dir__from_env_var__multiple(tmp_path):
tmpdir = os.pathsep.join([str(tmp_path) for _ in range(3)])
with proj_env(), patch.dict(os.environ, {"PROJ_DATA": tmpdir}, clear=True), patch(
"pyproj.datadir.Path.absolute", return_value=_INVALID_PATH
), patch("pyproj.datadir.sys.prefix", str(_INVALID_PATH)):
create_projdb(tmp_path)
assert get_data_dir() == tmpdir
def test_get_data_dir__from_prefix(tmp_path):
with proj_env(), patch.dict(os.environ, {}, clear=True), patch(
"pyproj.datadir.Path.absolute", return_value=_INVALID_PATH
), patch("pyproj.datadir.sys.prefix", str(tmp_path)):
proj_dir = tmp_path / "share" / "proj"
proj_dir.mkdir(parents=True)
create_projdb(proj_dir)
assert get_data_dir() == str(proj_dir)
def test_get_data_dir__from_prefix__conda_windows(tmp_path):
with proj_env(), patch.dict(os.environ, {}, clear=True), patch(
"pyproj.datadir.Path.absolute", return_value=_INVALID_PATH
), patch("pyproj.datadir.sys.prefix", str(tmp_path)):
proj_dir = tmp_path / "Library" / "share" / "proj"
proj_dir.mkdir(parents=True)
create_projdb(proj_dir)
assert get_data_dir() == str(proj_dir)
def test_get_data_dir__from_path(tmp_path):
with proj_env(), patch.dict(os.environ, {}, clear=True), patch(
"pyproj.datadir.Path.absolute", return_value=_INVALID_PATH
), patch("pyproj.datadir.sys.prefix", str(_INVALID_PATH)), patch(
"pyproj.datadir.shutil.which", return_value=str(tmp_path / "bin" / "proj")
):
proj_dir = tmp_path / "share" / "proj"
proj_dir.mkdir(parents=True)
create_projdb(proj_dir)
assert get_data_dir() == str(proj_dir)
@pytest.mark.parametrize("projdir_type", [str, Path])
def test_append_data_dir__internal(projdir_type, tmp_path):
with proj_env(), patch.dict(os.environ, {}, clear=True), patch(
"pyproj.datadir.Path.absolute", return_value=tmp_path / "datadir.py"
), patch("pyproj.datadir.sys.prefix", str(_INVALID_PATH)):
create_projdb(tmp_path)
internal_proj_dir = tmp_path / "proj_dir" / "share" / "proj"
internal_proj_dir.mkdir(parents=True)
create_projdb(internal_proj_dir)
extra_datadir = tmp_path / "extra_datumgrids"
append_data_dir(projdir_type(extra_datadir))
assert get_data_dir() == os.pathsep.join(
[str(internal_proj_dir), str(extra_datadir)]
)
@pytest.mark.slow
def test_creating_multiple_crs_without_file_limit():
"""
This test checks for two things:
1. Ensure database connection is closed for file limit
https://github.com/pyproj4/pyproj/issues/374
2. Ensure core-dumping does not occur when many objects are created
https://github.com/pyproj4/pyproj/issues/678
"""
codes = get_codes("EPSG", PJType.PROJECTED_CRS, False)
assert [CRS.from_epsg(code) for code in codes]
def test_get_user_data_dir():
assert get_user_data_dir().endswith("proj")
@patch.dict("os.environ", {"PYPROJ_GLOBAL_CONTEXT": "ON"}, clear=True)
def test_set_use_global_context__default_on():
with proj_context_env():
set_use_global_context()
assert pyproj._datadir._USE_GLOBAL_CONTEXT is True
@patch.dict("os.environ", {"PYPROJ_GLOBAL_CONTEXT": "OFF"}, clear=True)
def test_set_use_global_context__default_off():
with proj_context_env():
set_use_global_context()
assert pyproj._datadir._USE_GLOBAL_CONTEXT is False
@patch.dict("os.environ", {}, clear=True)
def test_set_use_global_context__default():
with proj_context_env():
set_use_global_context()
assert pyproj._datadir._USE_GLOBAL_CONTEXT is False
@patch.dict("os.environ", {"PYPROJ_GLOBAL_CONTEXT": "OFF"}, clear=True)
def test_set_use_global_context__on():
with proj_context_env():
set_use_global_context(True)
assert pyproj._datadir._USE_GLOBAL_CONTEXT is True
@patch.dict("os.environ", {"PYPROJ_GLOBAL_CONTEXT": "ON"}, clear=True)
def test_set_use_global_context__off():
with proj_context_env():
set_use_global_context(False)
assert pyproj._datadir._USE_GLOBAL_CONTEXT is False
def test_proj_debug_logging(capsys):
with proj_logging_env():
with pytest.warns(FutureWarning):
transformer = Transformer.from_proj("+init=epsg:4326", "+init=epsg:27700")
transformer.transform(100000, 100000)
captured = capsys.readouterr()
if os.environ.get("PROJ_DEBUG") == "3":
assert "PROJ_TRACE" in captured.err
assert "PROJ_DEBUG" in captured.err
elif os.environ.get("PROJ_DEBUG") == "2":
assert "PROJ_TRACE" not in captured.err
assert "PROJ_DEBUG" in captured.err
else:
assert "PROJ_ERROR" in captured.err
def test_proj_debug_logging__error(capsys):
with proj_logging_env(), pytest.raises(CRSError):
CRS("INVALID STRING")
captured = capsys.readouterr()
if os.environ.get("PROJ_DEBUG") == "3":
assert "PROJ_TRACE" in captured.err
assert "PROJ_DEBUG" in captured.err
assert "PROJ_ERROR" in captured.err
elif os.environ.get("PROJ_DEBUG") == "2":
assert "PROJ_TRACE" not in captured.err
assert "PROJ_DEBUG" in captured.err
assert "PROJ_ERROR" in captured.err
else:
assert captured.err == ""
assert captured.out == ""
pyproj-3.6.1/test/test_datum.py 0000664 0000000 0000000 00000001527 14502715416 0016560 0 ustar 00root root 0000000 0000000 import pytest
from numpy.testing import assert_almost_equal
from pyproj import CRS, Proj, transform
from test.conftest import grids_available
@pytest.mark.grid
@pytest.mark.parametrize("proj_class", [Proj, CRS])
def test_datum(proj_class):
p1 = proj_class(proj="latlong", datum="WGS84")
s_1 = -111.5
s_2 = 45.25919444444
p2 = proj_class(proj="utm", zone=10, datum="NAD27")
with pytest.warns(FutureWarning):
x2, y2 = transform(p1, p2, s_1, s_2)
if grids_available("us_noaa_emhpgn.tif"):
assert_almost_equal((x2, y2), (1402286.33, 5076292.30), decimal=2)
elif grids_available("us_noaa_conus.tif"):
assert_almost_equal((x2, y2), (1402285.98, 5076292.42), decimal=2)
else:
# https://github.com/OSGeo/PROJ/issues/1808
assert_almost_equal((x2, y2), (1402288.54, 5076296.64), decimal=2)
pyproj-3.6.1/test/test_datum_shift.py 0000664 0000000 0000000 00000004324 14502715416 0017753 0 ustar 00root root 0000000 0000000 import pytest
from numpy.testing import assert_almost_equal
from pyproj import Proj, transform
# illustrates the use of the transform function to
# perform coordinate transformations with datum shifts.
#
# This example is from Roberto Vidmar
#
# Test point is Trieste, Molo Sartorio
#
# This data come from the Istituto Geografico Militare (IGM), as well as
# the 7 parameters to transform from Gauss-Boaga (our reference frame)
# to WGS84
#
# WGS84 Lat: 45d38'49.879" (45.647188611)
# WGS84 Lon: 13d45'34.397" (13.759554722)
# WGS84 z: 52.80;
# UTM 33: 403340.97 5055597.17
# GB: 2423346.99 5055619.87
UTM_x = 403340.9672367854
UTM_y = 5055597.175553089
GB_x = 2423346.99
GB_y = 5055619.87
WGS84_lat = 45.647188611 # Degrees
WGS84_lon = 13.759554722 # Degrees
UTM_z = WGS84_z = 52.8 # Ellipsoidical height in meters
WGS84_PROJ = Proj(proj="latlong", datum="WGS84")
UTM_33_PROJ = Proj(proj="utm", zone="33")
with pytest.warns(FutureWarning):
GAUSSSB_PROJ = Proj(
init="epsg:3004", towgs84="-122.74,-34.27,-22.83,-1.884,-3.400,-3.030,-15.62"
)
def test_shift_wgs84_to_utm33():
with pytest.warns(FutureWarning):
xutm33, yutm33, zutm33 = transform(
WGS84_PROJ, UTM_33_PROJ, WGS84_lon, WGS84_lat, WGS84_z
)
assert_almost_equal((xutm33, yutm33, zutm33), (UTM_x, UTM_y, UTM_z))
def test_shift_utm33_to_wgs84():
with pytest.warns(FutureWarning):
back_lon, back_lat, back_z = transform(
UTM_33_PROJ, WGS84_PROJ, UTM_x, UTM_y, UTM_z
)
assert_almost_equal((back_lon, back_lat, back_z), (WGS84_lon, WGS84_lat, WGS84_z))
def test_shift_wgs84_to_gaussb_no_ellipsoidal_height():
with pytest.warns(FutureWarning):
xgb, ygb, zgb = transform(WGS84_PROJ, GAUSSSB_PROJ, WGS84_lon, WGS84_lat, 0)
assert_almost_equal((xgb, ygb, zgb), (GB_x, 5055619.899, 0), decimal=2)
def test_shift_gaussb_to_wgs84_no_ellipsoidal_height():
with pytest.warns(FutureWarning):
back_lon, back_lat, back_z = transform(GAUSSSB_PROJ, WGS84_PROJ, GB_x, GB_y, 0)
assert_almost_equal(
(back_lon, back_lat, back_z), (WGS84_lon, WGS84_lat, 0), decimal=3
)
pyproj-3.6.1/test/test_doctest_wrapper.py 0000664 0000000 0000000 00000003105 14502715416 0020645 0 ustar 00root root 0000000 0000000 """
This is a wrapper for the doctests in pyproj
"""
import doctest
import warnings
import pytest
import pyproj
from test.conftest import proj_network_env
def test_doctests():
"""run the examples in the docstrings using the doctest module"""
with warnings.catch_warnings():
warnings.filterwarnings(
"ignore",
"You will likely lose important projection information when",
UserWarning,
)
failure_count_proj, test_count = doctest.testmod(pyproj.proj, verbose=True)
failure_count_crs, test_count_crs = doctest.testmod(pyproj.crs, verbose=True)
failure_count_geod, test_count_geod = doctest.testmod(pyproj.geod, verbose=True)
failure_count = failure_count_proj + failure_count_crs + failure_count_geod
expected_failure_count = 0
try:
import shapely.geometry # noqa: F401 pylint: disable=unused-import
except (ImportError, OSError):
# missing shapely
expected_failure_count = 6
# if the below line fails, doctests have failed
assert (
failure_count == expected_failure_count
), f"{failure_count} of the doctests failed"
@pytest.mark.network
def test_doctests__network():
"""run the examples in the docstrings using the doctest module
that require the network
"""
with proj_network_env():
pyproj.network.set_network_enabled(active=True)
with pytest.warns(FutureWarning):
failure_count, _ = doctest.testmod(pyproj.transformer, verbose=True)
assert failure_count == 0, f"{failure_count} of the doctests failed"
pyproj-3.6.1/test/test_exception_logging.py 0000664 0000000 0000000 00000000523 14502715416 0021145 0 ustar 00root root 0000000 0000000 import pytest
from pyproj import CRS, Proj
from pyproj.exceptions import CRSError, ProjError
def test_proj_exception():
with pytest.raises(ProjError, match="Internal Proj Error"):
Proj("+proj=bobbyjoe")
def test_crs_exception():
with pytest.raises(CRSError, match="Internal Proj Error"):
CRS("+proj=bobbyjoe")
pyproj-3.6.1/test/test_geod.py 0000664 0000000 0000000 00000065324 14502715416 0016371 0 ustar 00root root 0000000 0000000 import math
import pickle
from contextlib import nullcontext
from itertools import permutations
import numpy
import pytest
from numpy.testing import assert_almost_equal, assert_array_equal
from pyproj import Geod
from pyproj.geod import GeodIntermediateFlag, reverse_azimuth
try:
from shapely.geometry import (
LinearRing,
LineString,
MultiLineString,
MultiPoint,
MultiPolygon,
Point,
Polygon,
)
from shapely.geometry.polygon import orient
SHAPELY_LOADED = True
except (ImportError, OSError):
SHAPELY_LOADED = False
skip_shapely = pytest.mark.skipif(not SHAPELY_LOADED, reason="Missing shapely")
# BOSTON
_BOSTON_LAT = 42.0 + (15.0 / 60.0)
_BOSTON_LON = -71.0 - (7.0 / 60.0)
# PORTLAND
_PORTLAND_LAT = 45.0 + (31.0 / 60.0)
_PORTLAND_LON = -123.0 - (41.0 / 60.0)
@pytest.mark.parametrize("return_back_azimuth", [True, False])
@pytest.mark.parametrize(
"ellipsoid,true_az12,true_az21,expected_distance",
[
("clrk66", -66.5305947876623, 75.65363415556968, 4164192.708),
("WGS84", -66.5305947876623, 75.65363415556968, 4164074.239),
],
)
def test_geodesic_inv(
ellipsoid,
true_az12,
true_az21,
expected_distance,
return_back_azimuth,
scalar_and_array,
):
geod = Geod(ellps=ellipsoid)
az12, az21, dist = geod.inv(
scalar_and_array(_BOSTON_LON),
scalar_and_array(_BOSTON_LAT),
scalar_and_array(_PORTLAND_LON),
scalar_and_array(_PORTLAND_LAT),
return_back_azimuth=return_back_azimuth,
)
if not return_back_azimuth:
az21 = reverse_azimuth(az21)
assert_almost_equal(
(az12, az21, dist),
(
scalar_and_array(true_az12),
scalar_and_array(true_az21),
scalar_and_array(expected_distance),
),
decimal=3,
)
@pytest.mark.parametrize(
"lon_start,lat_start,lon_end,lat_end,res12,res21,resdist",
[
(_BOSTON_LON, _BOSTON_LAT, _BOSTON_LON, _BOSTON_LAT, 180.0, 0.0, 0.0),
(
_BOSTON_LON,
_BOSTON_LAT,
-80.79664651607472,
44.83744724383204,
-66.53059478766238,
106.79071710136431,
832838.5416198927,
),
(
-80.79664651607472,
44.83744724383204,
-91.21816704002396,
46.536201500764776,
-73.20928289863558,
99.32289055927389,
832838.5416198935,
),
(
-91.21816704002396,
46.536201500764776,
-102.10621593474447,
47.236494630072166,
-80.67710944072617,
91.36325611787134,
832838.5416198947,
),
(
-102.10621593474447,
47.236494630072166,
-113.06616309750775,
46.88821539471925,
-88.63674388212858,
83.32809401477382,
832838.5416198922,
),
(
-113.06616309750775,
46.88821539471925,
_PORTLAND_LON,
_PORTLAND_LAT,
-96.67190598522616,
75.65363415556973,
832838.5416198926,
),
],
)
def test_geodesic_inv__multiple_points(
lon_start, lat_start, lon_end, lat_end, res12, res21, resdist, scalar_and_array
):
geod = Geod(ellps="clrk66")
o_az12, o_az21, o_dist = geod.inv(
scalar_and_array(lon_start),
scalar_and_array(lat_start),
scalar_and_array(lon_end),
scalar_and_array(lat_end),
)
assert_almost_equal(
(o_az12, o_az21, o_dist),
(scalar_and_array(res12), scalar_and_array(res21), scalar_and_array(resdist)),
)
@pytest.mark.parametrize(
"flag", [GeodIntermediateFlag.AZIS_DISCARD, GeodIntermediateFlag.AZIS_KEEP]
)
def test_geodesic_inv_intermediate__azis_flag(flag):
geod = Geod(ellps="clrk66")
point_count = 7
res = geod.inv_intermediate(
lon1=_BOSTON_LON,
lat1=_BOSTON_LAT,
lon2=_PORTLAND_LON,
lat2=_PORTLAND_LAT,
npts=point_count,
initial_idx=0,
terminus_idx=0,
flags=flag,
return_back_azimuth=False,
)
assert res.npts == point_count
assert_almost_equal(res.del_s, 694032.1180165777)
assert_almost_equal(res.dist, 4164192.7080994663)
assert_almost_equal(
res.lons,
[
_BOSTON_LON,
-79.12667425528419,
-87.67579185665936,
-96.62666097960022,
-105.7727853838606,
-114.86985739838673,
_PORTLAND_LON,
],
)
assert_almost_equal(
res.lats,
[
_BOSTON_LAT,
44.46434542986116,
46.07643938331146,
47.0159762562249,
47.23724050253994,
46.72890509939583,
_PORTLAND_LAT,
],
)
if flag == GeodIntermediateFlag.AZIS_DISCARD:
assert res.azis is None
else:
assert_almost_equal(
res.azis,
[
-66.5305947876623,
-72.03560255472611,
-78.11540731053181,
-84.61959820187617,
-91.32904268899453,
-97.98697931255812,
-104.34636584443031,
],
)
@pytest.mark.parametrize(
"flag", [GeodIntermediateFlag.AZIS_DISCARD, GeodIntermediateFlag.AZIS_KEEP]
)
def test_geodesic_inv_intermediate__azis_flag__numpy(flag):
geod = Geod(ellps="clrk66")
point_count = 3
lons_b = numpy.empty(point_count)
lats_b = numpy.empty(point_count)
res = geod.inv_intermediate(
out_lons=lons_b,
out_lats=lats_b,
lon1=_BOSTON_LON,
lat1=_BOSTON_LAT,
lon2=_PORTLAND_LON,
lat2=_PORTLAND_LAT,
npts=point_count,
initial_idx=0,
terminus_idx=0,
flags=flag,
return_back_azimuth=False,
)
assert res.npts == point_count
assert_almost_equal(res.del_s, 2082096.3540497331)
assert_almost_equal(res.dist, 4164192.7080994663)
assert_almost_equal(res.lons, [_BOSTON_LON, -96.62666098, _PORTLAND_LON])
assert_almost_equal(
res.lats,
[_BOSTON_LAT, 47.01597626, _PORTLAND_LAT],
)
if flag == GeodIntermediateFlag.AZIS_DISCARD:
assert res.azis is None
else:
assert_almost_equal(
res.azis,
[-66.5305947876623, -84.61959820187617, -104.34636584443031],
)
assert res.lons is lons_b
assert res.lats is lats_b
@pytest.mark.parametrize("return_back_azimuth", [True, False])
def test_geodesic_inv_intermediate__numpy(return_back_azimuth):
geod = Geod(ellps="clrk66")
point_count = 5
lons = numpy.empty(point_count)
lats = numpy.empty(point_count)
azis = numpy.empty(point_count)
with pytest.warns(UserWarning) if return_back_azimuth is None else nullcontext():
res = geod.inv_intermediate(
out_lons=lons,
out_lats=lats,
out_azis=azis,
lon1=_BOSTON_LON,
lat1=_BOSTON_LAT,
lon2=_PORTLAND_LON,
lat2=_PORTLAND_LAT,
npts=point_count,
initial_idx=0,
terminus_idx=0,
return_back_azimuth=return_back_azimuth,
)
assert res.npts == point_count
assert_almost_equal(res.del_s, 1041048.1770248666)
assert_almost_equal(res.dist, 4164192.7080994663)
assert_almost_equal(
res.lons,
[_BOSTON_LON, -83.34061499, -96.62666098, -110.34292364, _PORTLAND_LON],
)
assert_almost_equal(
res.lats, [_BOSTON_LAT, 45.35049848, 47.01597626, 47.07350417, _PORTLAND_LAT]
)
out_azis = res.azis[:-1]
if return_back_azimuth in [True, None]:
out_azis = reverse_azimuth(out_azis)
assert_almost_equal(
out_azis, [-66.53059479, -75.01125433, -84.6195982, -94.68069764]
)
assert res.lons is lons
assert res.lats is lats
assert res.azis is azis
@pytest.mark.parametrize(
"del_s_fact,flag",
[
(1, GeodIntermediateFlag.NPTS_ROUND),
(4.5 / 5, GeodIntermediateFlag.NPTS_TRUNC),
(5.5 / 5, GeodIntermediateFlag.NPTS_CEIL),
],
)
def test_geodesic_inv_intermediate__del_s__numpy(del_s_fact, flag):
geod = Geod(ellps="clrk66")
point_count = 5
lons = numpy.empty(point_count)
lats = numpy.empty(point_count)
azis = numpy.empty(point_count)
dist = 4164192.7080994663
del_s = dist / (point_count - 1)
res = geod.inv_intermediate(
out_lons=lons,
out_lats=lats,
out_azis=azis,
lon1=_BOSTON_LON,
lat1=_BOSTON_LAT,
lon2=_PORTLAND_LON,
lat2=_PORTLAND_LAT,
del_s=del_s * del_s_fact,
initial_idx=0,
terminus_idx=0,
flags=flag,
return_back_azimuth=False,
)
assert res.npts == point_count
assert_almost_equal(res.del_s, del_s)
assert_almost_equal(res.dist, dist)
assert_almost_equal(
res.lons,
[_BOSTON_LON, -83.34061499, -96.62666098, -110.34292364, _PORTLAND_LON],
)
assert_almost_equal(
res.lats, [_BOSTON_LAT, 45.35049848, 47.01597626, 47.07350417, _PORTLAND_LAT]
)
assert_almost_equal(
res.azis[:-1], [-66.53059479, -75.01125433, -84.6195982, -94.68069764]
)
assert res.lons is lons
assert res.lats is lats
assert res.azis is azis
@pytest.mark.parametrize("return_back_azimuth", [True, False])
def test_geodesic_fwd_intermediate__numpy(return_back_azimuth):
geod = Geod(ellps="clrk66")
point_count = 5
lons = numpy.empty(point_count)
lats = numpy.empty(point_count)
azis = numpy.empty(point_count)
true_az12 = -66.5305947876623
dist = 4164192.7080994663
del_s = dist / (point_count - 1)
with pytest.warns(UserWarning) if return_back_azimuth is None else nullcontext():
res = geod.fwd_intermediate(
out_lons=lons,
out_lats=lats,
out_azis=azis,
lon1=_BOSTON_LON,
lat1=_BOSTON_LAT,
azi1=true_az12,
npts=point_count,
del_s=del_s,
initial_idx=0,
terminus_idx=0,
return_back_azimuth=return_back_azimuth,
)
assert res.npts == point_count
assert res.lons is lons
assert res.lats is lats
assert res.azis is azis
assert_almost_equal(res.del_s, del_s)
assert_almost_equal(res.dist, dist)
assert_almost_equal(
res.lons,
[-71.11666667, -83.34061499, -96.62666098, -110.34292364, -123.68333333],
)
assert_almost_equal(
res.lats, [42.25, 45.35049848, 47.01597626, 47.07350417, 45.51666667]
)
if return_back_azimuth in [True, None]:
azis = reverse_azimuth(azis)
assert_almost_equal(
azis, [-66.53059479, -75.01125433, -84.6195982, -94.68069764, -104.34636584]
)
@pytest.mark.parametrize("return_back_azimuth", [True, False])
@pytest.mark.parametrize(
"ellipsoid,true_az12,true_az21,expected_distance",
[
("clrk66", -66.5305947876623, 75.65363415556968, 4164192.708),
("WGS84", -66.5305947876623, 75.65363415556968, 4164074.239),
],
)
def test_geodesic_fwd(
ellipsoid,
true_az12,
true_az21,
expected_distance,
return_back_azimuth,
scalar_and_array,
):
geod = Geod(ellps=ellipsoid)
endlon, endlat, backaz = geod.fwd(
scalar_and_array(_BOSTON_LON),
scalar_and_array(_BOSTON_LAT),
scalar_and_array(true_az12),
scalar_and_array(expected_distance),
return_back_azimuth=return_back_azimuth,
)
if not return_back_azimuth:
backaz = reverse_azimuth(backaz)
assert_almost_equal(
(endlon, endlat, backaz),
(
scalar_and_array(_PORTLAND_LON),
scalar_and_array(_PORTLAND_LAT),
scalar_and_array(true_az21),
),
decimal=3,
)
@pytest.mark.parametrize("include_initial", [True, False])
@pytest.mark.parametrize("include_terminus", [True, False])
def test_geodesic_npts(include_initial, include_terminus):
geod = Geod(ellps="clrk66")
initial_idx = int(not include_initial)
terminus_idx = int(not include_terminus)
lonlats = geod.npts(
_BOSTON_LON,
_BOSTON_LAT,
_PORTLAND_LON,
_PORTLAND_LAT,
npts=6 - initial_idx - terminus_idx,
initial_idx=initial_idx,
terminus_idx=terminus_idx,
)
expected_lonlats = [
(-80.797, 44.837),
(-91.218, 46.536),
(-102.106, 47.236),
(-113.066, 46.888),
]
if include_initial:
expected_lonlats.insert(0, (_BOSTON_LON, _BOSTON_LAT))
if include_terminus:
expected_lonlats.append((_PORTLAND_LON, _PORTLAND_LAT))
assert_almost_equal(lonlats, expected_lonlats, decimal=3)
@pytest.mark.parametrize(
"input_data",
[
[1.0, 2.0, 3.0, math.nan],
[1.0, 2.0, math.nan, 4.0],
[1.0, math.nan, 3.0, 4.0],
[math.nan, 2.0, 3.0, 4.0],
[math.nan, math.nan, math.nan, math.nan],
],
)
def test_geodesic_npts__nan(input_data):
geod = Geod(ellps="WGS84")
assert_array_equal(geod.npts(*input_data, npts=1), [(math.nan, math.nan)])
@pytest.mark.parametrize(
"ellipsoid,expected_azi12,expected_az21,expected_dist",
[("clrk66", -66.531, 75.654, 4164192.708), ("WGS84", -66.530, 75.654, 4164074.239)],
)
def test_geodesic_inv__pickle(
ellipsoid, expected_azi12, expected_az21, expected_dist, tmp_path, scalar_and_array
):
geod = Geod(ellps=ellipsoid)
az12, az21, dist = geod.inv(
scalar_and_array(_BOSTON_LON),
scalar_and_array(_BOSTON_LAT),
scalar_and_array(_PORTLAND_LON),
scalar_and_array(_PORTLAND_LAT),
)
assert_almost_equal(
(az12, az21, dist),
(
scalar_and_array(expected_azi12),
scalar_and_array(expected_az21),
scalar_and_array(expected_dist),
),
decimal=3,
)
pickle_file = tmp_path / "geod1.pickle"
with open(pickle_file, "wb") as gp1w:
pickle.dump(geod, gp1w, -1)
with open(pickle_file, "rb") as gp1:
geod_pickle = pickle.load(gp1)
pickle_az12, pickle_az21, pickle_dist = geod_pickle.inv(
scalar_and_array(_BOSTON_LON),
scalar_and_array(_BOSTON_LAT),
scalar_and_array(_PORTLAND_LON),
scalar_and_array(_PORTLAND_LAT),
)
assert_almost_equal(
(pickle_az12, pickle_az21, pickle_dist),
(
scalar_and_array(expected_azi12),
scalar_and_array(expected_az21),
scalar_and_array(expected_dist),
),
decimal=3,
)
def test_geodesic_inv__string_init(scalar_and_array):
geod = Geod("+ellps=clrk66")
az12, az21, dist = geod.inv(
scalar_and_array(_BOSTON_LON),
scalar_and_array(_BOSTON_LAT),
scalar_and_array(_PORTLAND_LON),
scalar_and_array(_PORTLAND_LAT),
)
assert_almost_equal(
(az12, az21, dist),
(
scalar_and_array(-66.531),
scalar_and_array(75.654),
scalar_and_array(4164192.708),
),
decimal=3,
)
def test_line_length__single_point():
geod = Geod(ellps="WGS84")
assert geod.line_length(1, 1) == 0
def test_line_length__radians():
geod = Geod(ellps="WGS84")
total_length = geod.line_length([1, 2], [0.5, 1], radians=True)
assert_almost_equal(total_length, 5426061.32197463, decimal=3)
def test_line_lengths__single_point():
geod = Geod(ellps="WGS84")
assert geod.line_lengths(1, 1) == 0
def test_line_lengths__radians():
geod = Geod(ellps="WGS84")
line_lengths = geod.line_lengths([1, 2], [0.5, 1], radians=True)
assert_almost_equal(line_lengths, [5426061.32197463], decimal=3)
def test_polygon_area_perimeter__single_point():
geod = Geod(ellps="WGS84")
area, perimeter = geod.polygon_area_perimeter(1, 1)
assert area == 0
assert perimeter == 0
@skip_shapely
def test_geometry_length__point():
geod = Geod(ellps="WGS84")
assert geod.geometry_length(Point(1, 2)) == 0
@skip_shapely
def test_geometry_length__linestring():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_length(LineString([Point(1, 2), Point(3, 4)])),
313588.39721259556,
decimal=2,
)
@skip_shapely
def test_geometry_length__linestring__radians():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_length(
LineString(
[
Point(math.radians(1), math.radians(2)),
Point(math.radians(3), math.radians(4)),
]
),
radians=True,
),
313588.39721259556,
decimal=2,
)
@skip_shapely
def test_geometry_length__linearring():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_length(
LinearRing(LineString([Point(1, 2), Point(3, 4), Point(5, 2)]))
),
1072185.2103813463,
decimal=2,
)
@skip_shapely
def test_geometry_length__polygon():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_length(
Polygon(LineString([Point(1, 2), Point(3, 4), Point(5, 2)]))
),
1072185.2103813463,
decimal=2,
)
@skip_shapely
def test_geometry_length__polygon__radians():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_length(
Polygon(
LineString(
[
Point(math.radians(1), math.radians(2)),
Point(math.radians(3), math.radians(4)),
Point(math.radians(5), math.radians(2)),
]
)
),
radians=True,
),
1072185.2103813463,
decimal=2,
)
@skip_shapely
def test_geometry_length__multipolygon():
geod = Geod(ellps="WGS84")
polygon = Polygon(LineString([Point(1, 2), Point(3, 4), Point(5, 2)]))
assert_almost_equal(
geod.geometry_length(MultiPolygon([polygon, polygon])),
2 * 1072185.2103813463,
decimal=2,
)
@skip_shapely
def test_geometry_length__multipolygon__radians():
geod = Geod(ellps="WGS84")
polygon = Polygon(
LineString(
[
Point(math.radians(1), math.radians(2)),
Point(math.radians(3), math.radians(4)),
Point(math.radians(5), math.radians(2)),
]
)
)
assert_almost_equal(
geod.geometry_length(MultiPolygon([polygon, polygon]), radians=True),
2 * 1072185.2103813463,
decimal=2,
)
@skip_shapely
def test_geometry_length__multilinestring():
geod = Geod(ellps="WGS84")
line_string = LineString([Point(1, 2), Point(3, 4), Point(5, 2)])
assert_almost_equal(
geod.geometry_length(MultiLineString([line_string, line_string])),
1254353.5888503822,
decimal=2,
)
@skip_shapely
def test_geometry_length__multipoint():
geod = Geod(ellps="WGS84")
assert (
geod.geometry_length(MultiPoint([Point(1, 2), Point(3, 4), Point(5, 2)])) == 0
)
@skip_shapely
def test_geometry_area_perimeter__point():
geod = Geod(ellps="WGS84")
assert geod.geometry_area_perimeter(Point(1, 2)) == (0, 0)
@skip_shapely
def test_geometry_area_perimeter__linestring():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_area_perimeter(LineString([Point(1, 2), Point(3, 4)])),
(0.0, 627176.7944251911),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__linestring__radians():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_area_perimeter(
LineString(
[
Point(math.radians(1), math.radians(2)),
Point(math.radians(3), math.radians(4)),
]
),
radians=True,
),
(0.0, 627176.7944251911),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__linearring():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_area_perimeter(
LinearRing(LineString([Point(1, 2), Point(3, 4), Point(5, 2)]))
),
(-49187690467.58623, 1072185.2103813463),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__polygon():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_area_perimeter(
Polygon(LineString([Point(1, 2), Point(3, 4), Point(5, 2)]))
),
(-49187690467.58623, 1072185.2103813463),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__polygon__radians():
geod = Geod(ellps="WGS84")
assert_almost_equal(
geod.geometry_area_perimeter(
Polygon(
LineString(
[
Point(math.radians(1), math.radians(2)),
Point(math.radians(3), math.radians(4)),
Point(math.radians(5), math.radians(2)),
]
)
),
radians=True,
),
(-49187690467.58623, 1072185.2103813463),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__polygon__holes():
geod = Geod(ellps="WGS84")
polygon = Polygon(
LineString([Point(1, 1), Point(1, 10), Point(10, 10), Point(10, 1)]),
holes=[LineString([Point(1, 2), Point(3, 4), Point(5, 2)])],
)
assert_almost_equal(
geod.geometry_area_perimeter(orient(polygon, 1)),
(944373881400.3394, 3979008.0359657984),
decimal=2,
)
assert_almost_equal(
geod.geometry_area_perimeter(orient(polygon, -1)),
(-944373881400.3394, 3979008.0359657984),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__multipolygon():
geod = Geod(ellps="WGS84")
polygon = Polygon(LineString([Point(1, 2), Point(3, 4), Point(5, 2)]))
assert_almost_equal(
geod.geometry_area_perimeter(MultiPolygon([polygon, polygon])),
(-98375380935.17245, 2144370.4207626926),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__multipolygon__radians():
geod = Geod(ellps="WGS84")
polygon = Polygon(
LineString(
[
Point(math.radians(1), math.radians(2)),
Point(math.radians(3), math.radians(4)),
Point(math.radians(5), math.radians(2)),
]
)
)
assert_almost_equal(
geod.geometry_area_perimeter(MultiPolygon([polygon, polygon]), radians=True),
(-98375380935.17245, 2144370.4207626926),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__multilinestring():
geod = Geod(ellps="WGS84")
line_string = LineString([Point(1, 2), Point(3, 4), Point(5, 2)])
assert_almost_equal(
geod.geometry_area_perimeter(MultiLineString([line_string, line_string])),
(-98375380935.17245, 2144370.4207626926),
decimal=2,
)
@skip_shapely
def test_geometry_area_perimeter__multipoint():
geod = Geod(ellps="WGS84")
assert geod.geometry_area_perimeter(
MultiPoint([Point(1, 2), Point(3, 4), Point(5, 2)])
) == (0, 0)
@pytest.mark.parametrize(
"lon,lat,az", permutations([10.0, [10.0], (10.0,)])
) # 6 test cases
def test_geod_fwd_honours_input_types(lon, lat, az):
# 622
gg = Geod(ellps="clrk66")
outx, outy, outz = gg.fwd(lons=lon, lats=lat, az=az, dist=0)
assert isinstance(outx, type(lon))
assert isinstance(outy, type(lat))
assert isinstance(outz, type(az))
def test_geod_fwd_radians():
g = Geod(ellps="clrk66")
lon1 = 1
lat1 = 1
az1 = 1
dist = 1
assert_almost_equal(
numpy.rad2deg(g.fwd(lon1, lat1, az1, dist, radians=True)),
g.fwd(lon1 * 180 / numpy.pi, lat1 * 180 / numpy.pi, az1 * 180 / numpy.pi, dist),
)
def test_geod_inv_radians():
g = Geod(ellps="clrk66")
lon1 = 0
lat1 = 0
lon2 = 1
lat2 = 1
# the third output is in distance, so we don't want to change from deg-rad there
out_rad = list(g.inv(lon1, lat1, lon2, lat2, radians=True))
out_rad[0] *= 180 / numpy.pi
out_rad[1] *= 180 / numpy.pi
assert_almost_equal(
out_rad,
g.inv(
lon1 * 180 / numpy.pi,
lat1 * 180 / numpy.pi,
lon2 * 180 / numpy.pi,
lat2 * 180 / numpy.pi,
),
)
@pytest.mark.parametrize("func_name", ("fwd", "inv"))
@pytest.mark.parametrize("radians", (True, False))
def test_geod_scalar_array(func_name, radians):
# verify two singlepoint calculations match an array of length two
g = Geod(ellps="clrk66")
func = getattr(g, func_name)
assert_almost_equal(
numpy.transpose([func(0, 0, 1, 1, radians=radians) for i in range(2)]),
func([0, 0], [0, 0], [1, 1], [1, 1], radians=radians),
)
@pytest.mark.parametrize(
"lons1,lats1,lons2", permutations([10.0, [10.0], (10.0,), numpy.array([10.0])], 3)
) # 6 test cases
def test_geod_inv_honours_input_types(lons1, lats1, lons2):
# 622
gg = Geod(ellps="clrk66")
outx, outy, outz = gg.inv(lons1=lons1, lats1=lats1, lons2=lons2, lats2=0)
assert isinstance(outx, type(lons1))
assert isinstance(outy, type(lats1))
assert isinstance(outz, type(lons2))
def test_geodesic_fwd_inv_inplace():
gg = Geod(ellps="clrk66")
_BOSTON_LON = numpy.array([0], dtype=numpy.float64)
_BOSTON_LAT = numpy.array([0], dtype=numpy.float64)
_PORTLAND_LON = numpy.array([1], dtype=numpy.float64)
_PORTLAND_LAT = numpy.array([1], dtype=numpy.float64)
az12, az21, dist = gg.inv(
_BOSTON_LON, _BOSTON_LAT, _PORTLAND_LON, _PORTLAND_LAT, inplace=True
)
assert az12 is _BOSTON_LON
assert az21 is _BOSTON_LAT
assert dist is _PORTLAND_LON
endlon, endlat, backaz = gg.fwd(_BOSTON_LON, _BOSTON_LAT, az12, dist, inplace=True)
assert endlon is _BOSTON_LON
assert endlat is _BOSTON_LAT
assert backaz is az12
@pytest.mark.parametrize("kwarg", ["b", "f", "es", "rf", "e"])
def test_geod__build_kwargs(kwarg):
gg = Geod(ellps="clrk66")
if kwarg == "rf":
value = 1.0 / gg.f
elif kwarg == "e":
value = math.sqrt(gg.es)
else:
value = getattr(gg, kwarg)
gg2 = Geod(a=gg.a, **{kwarg: value})
assert_almost_equal(gg.a, gg2.a)
assert_almost_equal(gg.b, gg2.b)
assert_almost_equal(gg.f, gg2.f)
assert_almost_equal(gg.es, gg2.es)
@pytest.mark.parametrize("radians", [False, True])
def test_geod__reverse_azimuth(radians):
f = math.pi / 180 if radians else 1
xy = numpy.array(
[
[0, 0 + 180],
[180, 180 - 180],
[-180, -180 + 180],
[10, 10 - 180],
[20, 20 - 180],
[-10, -10 + 180],
]
)
for x, y in xy:
assert_almost_equal(reverse_azimuth(x * f, radians=radians), y * f)
xx = xy.T[0]
yy = xy.T[1]
assert_almost_equal(reverse_azimuth(xx * f, radians=radians), yy * f)
pyproj-3.6.1/test/test_list.py 0000664 0000000 0000000 00000001611 14502715416 0016413 0 ustar 00root root 0000000 0000000 from numpy.testing import assert_almost_equal
from pyproj.list import get_ellps_map, get_prime_meridians_map, get_proj_operations_map
def test_backwards_compatible_import_paths():
from pyproj import ( # noqa: F401 pylint: disable=unused-import
get_ellps_map,
get_prime_meridians_map,
get_proj_operations_map,
)
def test_get_ellps_map():
ellps_map = get_ellps_map()
assert ellps_map["WGS84"]["description"] == "WGS 84"
assert_almost_equal(ellps_map["WGS84"]["a"], 6378137.0, decimal=1)
assert_almost_equal(ellps_map["WGS84"]["rf"], 298.257223563, decimal=1)
def test_get_prime_meridians_map():
prime_meridians_map = get_prime_meridians_map()
assert prime_meridians_map["greenwich"] == "0dE"
def test_get_proj_operations_map():
proj_operations_map = get_proj_operations_map()
assert proj_operations_map["aea"] == "Albers Equal Area"
pyproj-3.6.1/test/test_network.py 0000664 0000000 0000000 00000003442 14502715416 0017135 0 ustar 00root root 0000000 0000000 from unittest.mock import patch
import certifi
import pytest
from pyproj.network import set_ca_bundle_path
@patch.dict("os.environ", {}, clear=True)
@patch("pyproj.network._set_ca_bundle_path")
def test_ca_bundle_path__default(c_set_ca_bundle_path_mock):
set_ca_bundle_path()
c_set_ca_bundle_path_mock.assert_called_with(certifi.where())
@pytest.mark.parametrize(
"env_var", ["PROJ_CURL_CA_BUNDLE", "CURL_CA_BUNDLE", "SSL_CERT_FILE"]
)
@patch("pyproj.network._set_ca_bundle_path")
def test_ca_bundle_path__always_certifi(c_set_ca_bundle_path_mock, env_var):
with patch.dict("os.environ", {env_var: "/tmp/dummy/path/cacert.pem"}, clear=True):
set_ca_bundle_path(True)
c_set_ca_bundle_path_mock.assert_called_with(certifi.where())
@patch.dict("os.environ", {}, clear=True)
@patch("pyproj.network._set_ca_bundle_path")
def test_ca_bundle_path__skip(c_set_ca_bundle_path_mock):
set_ca_bundle_path(False)
c_set_ca_bundle_path_mock.assert_called_with("")
@pytest.mark.parametrize(
"env_var", ["PROJ_CURL_CA_BUNDLE", "CURL_CA_BUNDLE", "SSL_CERT_FILE"]
)
@patch("pyproj.network._set_ca_bundle_path")
def test_ca_bundle_path__env_var_skip(c_set_ca_bundle_path_mock, env_var):
with patch.dict("os.environ", {env_var: "/tmp/dummy/path/cacert.pem"}, clear=True):
set_ca_bundle_path()
c_set_ca_bundle_path_mock.assert_called_with("")
@pytest.mark.parametrize(
"env_var", ["PROJ_CURL_CA_BUNDLE", "CURL_CA_BUNDLE", "SSL_CERT_FILE"]
)
@patch("pyproj.network._set_ca_bundle_path")
def test_ca_bundle_path__custom_path(c_set_ca_bundle_path_mock, env_var):
with patch.dict("os.environ", {env_var: "/tmp/dummy/path/cacert.pem"}, clear=True):
set_ca_bundle_path("/my/path/to/cacert.pem")
c_set_ca_bundle_path_mock.assert_called_with("/my/path/to/cacert.pem")
pyproj-3.6.1/test/test_pickle.py 0000664 0000000 0000000 00000004447 14502715416 0016721 0 ustar 00root root 0000000 0000000 """run test.py first!"""
import os
import pickle
import shutil
import tempfile
from contextlib import contextmanager
import numpy
from numpy.testing import assert_allclose
from pyproj import Proj
try:
from time import perf_counter
except ImportError:
from time import clock as perf_counter
@contextmanager
def temporary_directory():
"""
Get a temporary directory
"""
temp_dir = tempfile.mkdtemp()
try:
yield temp_dir
finally:
shutil.rmtree(temp_dir)
def test_pickle():
nx = 349
ny = 277
dx = 32463.41
dy = dx
print("do it again, from pickled instance ...")
# find 4 lon/lat crnrs of AWIPS grid 221.
llcrnrx = 0.0
llcrnry = 0.0
urcrnrx = dx * (nx - 1)
urcrnry = dy * (ny - 1)
dx = (urcrnrx - llcrnrx) / (nx - 1)
dy = (urcrnry - llcrnry) / (ny - 1)
x = llcrnrx + dx * numpy.indices((ny, nx), "f")[1, :, :]
y = llcrnry + dy * numpy.indices((ny, nx), "f")[0, :, :]
awips221_pre_pickle = Proj(proj="lcc", R=6371200, lat_1=50, lat_2=50, lon_0=-107)
with temporary_directory() as tmpdir:
with open(os.path.join(tmpdir, "test.pickle"), "wb") as pfh:
pickle.dump(awips221_pre_pickle, pfh, -1)
with open(os.path.join(tmpdir, "test.pickle"), "rb") as prh:
awips221 = pickle.load(prh)
t1 = perf_counter()
lons, lats = awips221(x, y, inverse=True)
t2 = perf_counter()
print("compute lats/lons for all points on AWIPS 221 grid ({}x{})".format(nx, ny))
print("max/min lons in radians")
print(
numpy.minimum.reduce(numpy.ravel(lons)), numpy.maximum.reduce(numpy.ravel(lons))
)
print("max/min lats in radians")
print(
numpy.minimum.reduce(numpy.ravel(lats)), numpy.maximum.reduce(numpy.ravel(lats))
)
print("took", t2 - t1, "secs")
# reverse transformation.
t1 = perf_counter()
xx, yy = awips221(lons, lats)
t2 = perf_counter()
print("max abs error for x")
max_abs_err_x = numpy.maximum.reduce(numpy.fabs(numpy.ravel(x - xx)))
print(max_abs_err_x)
assert_allclose(max_abs_err_x, 0, atol=1e-4)
print("max abs error for y")
max_abs_err_y = numpy.maximum.reduce(numpy.fabs(numpy.ravel(y - yy)))
print(max_abs_err_y)
assert_allclose(max_abs_err_y, 0, atol=1e-4)
print("took", t2 - t1, "secs")
pyproj-3.6.1/test/test_proj.py 0000664 0000000 0000000 00000051773 14502715416 0016430 0 ustar 00root root 0000000 0000000 import concurrent.futures
import math
import os
import sys
import unittest
from unittest.mock import patch
import numpy
import pytest
from numpy.testing import assert_almost_equal
import pyproj
from pyproj import Geod, Proj, pj_ellps, pj_list, transform
from pyproj.exceptions import CRSError, ProjError
from pyproj.geod import reverse_azimuth
from test.conftest import proj_network_env
class BasicTest(unittest.TestCase):
def testInitWithBackupString4(self):
# this fails unless backup of to_string(4) is used
pj = Proj(
"+proj=merc +a=6378137.0 +b=6378137.0 +nadgrids=@null "
"+lon_0=0.0 +x_0=0.0 +y_0=0.0 +units=m +no_defs"
)
assert pj.crs.name == "unknown"
def testProjAwips221(self):
# AWIPS is Advanced Weather Interactive Processing System
params = {"proj": "lcc", "R": 6371200, "lat_1": 50, "lat_2": 50, "lon_0": -107}
awips221 = Proj(
proj=params["proj"],
R=params["R"],
lat_1=params["lat_1"],
lat_2=params["lat_2"],
lon_0=params["lon_0"],
preserve_units=False,
)
awips221_from_dict = Proj(params, preserve_units=False)
items = sorted(val for val in awips221.crs.srs.split() if val)
items_dict = sorted(val for val in awips221_from_dict.crs.srs.split() if val)
self.assertEqual(items, items_dict)
expected = sorted(
[
"+proj=lcc",
"+R=6371200",
"+lat_1=50",
"+lat_2=50",
"+lon_0=-107",
"+type=crs",
]
)
self.assertEqual(items, expected)
point = awips221(-145.5, 1.0)
x, y = -5632642.22547495, 1636571.4883145525
self.assertAlmostEqual(point[0], x)
self.assertAlmostEqual(point[1], y)
pairs = [
[(-45, 45), (4351601.20766915, 7606948.029327129)],
[(45, 45), (5285389.07739382, 14223336.17467613)],
[(45, -45), (20394982.466924712, 21736546.456803113)],
[(-45, -45), (16791730.756976362, -3794425.4816524936)],
]
for point_geog, expected in pairs:
point = awips221(*point_geog)
self.assertAlmostEqual(point[0], expected[0])
self.assertAlmostEqual(point[1], expected[1])
point_geog2 = awips221(*point, inverse=True)
self.assertAlmostEqual(point_geog[0], point_geog2[0])
self.assertAlmostEqual(point_geog[1], point_geog2[1])
def test_from_dict_with_bool(self):
# issue #183
p_d = {
"proj": "omerc",
"lat_2": 80.27942,
"lat_0": 62.87671,
"lat_1": 42.751232,
"ellps": "WGS84",
"no_rot": True,
"lon_1": 33.793186,
"lon_2": -18.374414,
}
p = Proj(p_d)
self.assertTrue("+no_rot" in p.srs.split())
p_d = {
"proj": "omerc",
"lat_2": 80.27942,
"lat_0": 62.87671,
"lat_1": 42.751232,
"ellps": "WGS84",
"no_rot": False,
"lon_1": 33.793186,
"lon_2": -18.374414,
}
p = Proj(p_d)
self.assertFalse("+no_rot" in p.srs.split())
class InverseHammerTest(unittest.TestCase):
# This is a unit test of the inverse of the hammer projection, which
# was added in the 4.9.3 version of PROJ (then PROJ.4).
@classmethod
def setUpClass(self):
self.p = Proj(proj="hammer") # hammer proj
self.x, self.y = self.p(-30, 40)
def test_forward(self):
self.assertAlmostEqual(self.x, -2711575.083, places=3)
self.assertAlmostEqual(self.y, 4395506.619, places=3)
def test_inverse(self):
lon, lat = self.p(self.x, self.y, inverse=True)
self.assertAlmostEqual(lon, -30.0, places=3)
self.assertAlmostEqual(lat, 40.0, places=3)
class TypeError_Transform_Issue8_Test(unittest.TestCase):
# Test for "Segmentation fault on pyproj.transform #8"
# https://github.com/jswhit/pyproj/issues/8
def setUp(self):
with pytest.warns(FutureWarning):
self.p = Proj(init="epsg:4269")
def test_tranform_none_1st_parmeter(self):
# test should raise Type error if projections are not of Proj classes
# version 1.9.4 produced AttributeError, now should raise TypeError
with pytest.warns(FutureWarning), pytest.raises(CRSError):
transform(None, self.p, -74, 39)
def test_tranform_none_2nd_parmeter(self):
# test should raise Type error if projections are not of Proj classes
# version 1.9.4 has a Segmentation Fault, now should raise TypeError
with pytest.warns(FutureWarning), pytest.raises(CRSError):
transform(self.p, None, -74, 39)
class Geod_NoDefs_Issue22_Test(unittest.TestCase):
# Test for Issue #22, Geod with "+no_defs" in initstring
# Before PR #23 merged 2015-10-07, having +no_defs in the
# initstring would result in a ValueError
def test_geod_nodefs(self):
Geod("+a=6378137 +b=6378137 +no_defs")
class ProjLatLongTypeErrorTest(unittest.TestCase):
# .latlong() using in transform raised a TypeError in release 1.9.5.1
# reported in issue #53, resolved in #73.
def test_latlong_typeerror(self):
p = Proj("+proj=stere +lon_0=-39 +lat_0=90 +lat_ts=71.0 +ellps=WGS84")
self.assertTrue(isinstance(p, Proj))
# if not patched this line raises a "TypeError: p2 must be a Proj class"
with pytest.warns(FutureWarning):
lon, lat = transform(p, p.to_latlong(), 200000, 400000)
@unittest.skipIf(
sys.version_info < (3, 4), "Python 3.4 or newer required for subTest()"
)
class ForwardInverseTest(unittest.TestCase):
def test_fwd_inv(self):
for pj in pj_list.keys():
with self.subTest(pj=pj):
try:
p = Proj(proj=pj)
x, y = p(-30, 40)
# note, for proj 4.9.2 or before the inverse projection
# may be missing and pyproj 1.9.5.1 or before does not
# test for this and will
# give a segmentation fault at this point:
lon, lat = p(x, y, inverse=True)
except RuntimeError:
pass
# Tests for shared memory between Geod objects
class GeodSharedMemoryBugTestIssue64(unittest.TestCase):
def setUp(self):
self.g = Geod(ellps="clrk66")
self.ga = self.g.a
self.mercury = Geod(a=2439700) # Mercury 2000 ellipsoid
# Mercury is much smaller than earth.
def test_not_shared_memory(self):
self.assertEqual(self.ga, self.g.a)
# mecury must have a different major axis from earth
self.assertNotEqual(self.g.a, self.mercury.a)
self.assertNotEqual(self.g.b, self.mercury.b)
self.assertNotEqual(self.g.sphere, self.mercury.sphere)
self.assertNotEqual(self.g.f, self.mercury.f)
self.assertNotEqual(self.g.es, self.mercury.es)
# initstrings were not shared in issue #64
self.assertNotEqual(self.g.initstring, self.mercury.initstring)
def test_distances(self):
# note calculated distance was not an issue with #64,
# but it still a shared memory test
boston_lat = 42.0 + (15.0 / 60.0)
boston_lon = -71.0 - (7.0 / 60.0)
portland_lat = 45.0 + (31.0 / 60.0)
portland_lon = -123.0 - (41.0 / 60.0)
az12, az21, dist_g = self.g.inv(
boston_lon, boston_lat, portland_lon, portland_lat
)
az12, az21, dist_mercury = self.mercury.inv(
boston_lon, boston_lat, portland_lon, portland_lat
)
self.assertLess(dist_mercury, dist_g)
class ReprTests(unittest.TestCase):
# test __repr__ for Proj object
def test_repr(self):
p = Proj(proj="latlong", preserve_units=True)
expected = (
"\n"
"Description: PROJ-based coordinate operation\n"
"Area of Use:\n"
"- undefined"
)
self.assertEqual(repr(p), expected)
# test __repr__ for Geod object
def test_sphere(self):
# ellipse is Venus 2000 (IAU2000:29900), which is a sphere
g = Geod("+a=6051800 +b=6051800")
self.assertEqual(repr(g), "Geod('+a=6051800 +f=0')")
# test __repr__ for Geod object
def test_ellps_name_round_trip(self):
# this could be done in a parameter fashion
for ellps_name in pj_ellps:
# skip tests, these ellipses NWL9D and WGS66 are the same
if ellps_name in ("NWL9D", "WGS66"):
continue
p = Geod(ellps=ellps_name)
expected = f"Geod(ellps='{ellps_name}')"
self.assertEqual(repr(p), expected)
class TestRadians(unittest.TestCase):
"""Tests issue #84"""
def setUp(self):
self.g = Geod(ellps="clrk66")
self.boston_d = (-71.0 - (7.0 / 60.0), 42.0 + (15.0 / 60.0))
self.boston_r = (math.radians(self.boston_d[0]), math.radians(self.boston_d[1]))
self.portland_d = (-123.0 - (41.0 / 60.0), 45.0 + (31.0 / 60.0))
self.portland_r = (
math.radians(self.portland_d[0]),
math.radians(self.portland_d[1]),
)
def test_inv_radians(self):
# Get bearings and distance from Boston to Portland in degrees
az12_d, az21_d, dist_d = self.g.inv(
self.boston_d[0],
self.boston_d[1],
self.portland_d[0],
self.portland_d[1],
radians=False,
)
# Get bearings and distance from Boston to Portland in radians
az12_r, az21_r, dist_r = self.g.inv(
self.boston_r[0],
self.boston_r[1],
self.portland_r[0],
self.portland_r[1],
radians=True,
)
# Check they are equal
self.assertAlmostEqual(az12_d, math.degrees(az12_r))
self.assertAlmostEqual(az21_d, math.degrees(az21_r))
self.assertAlmostEqual(dist_d, dist_r)
def test_fwd_radians(self):
# Get bearing and distance to Portland
az12_d, az21_d, dist = self.g.inv(
self.boston_d[0],
self.boston_d[1],
self.portland_d[0],
self.portland_d[1],
radians=False,
)
# Calculate Portland's lon/lat from bearing and distance in degrees
endlon_d, endlat_d, backaz_d = self.g.fwd(
self.boston_d[0], self.boston_d[1], az12_d, dist, radians=False
)
# Calculate Portland's lon/lat from bearing and distance in radians
for return_back_azimuth in [False, True]:
endlon_r, endlat_r, backaz_r = self.g.fwd(
self.boston_r[0],
self.boston_r[1],
math.radians(az12_d),
dist,
radians=True,
return_back_azimuth=return_back_azimuth,
)
if not return_back_azimuth:
backaz_r = reverse_azimuth(backaz_r, radians=True)
# Check they are equal
self.assertAlmostEqual(endlon_d, math.degrees(endlon_r))
self.assertAlmostEqual(endlat_d, math.degrees(endlat_r))
self.assertAlmostEqual(backaz_d, math.degrees(backaz_r))
# Check to make sure we're back in Portland
self.assertAlmostEqual(endlon_d, self.portland_d[0])
self.assertAlmostEqual(endlat_d, self.portland_d[1])
def test_npts_radians(self):
# Calculate 10 points between Boston and Portland in degrees
points_d = self.g.npts(
lon1=self.boston_d[0],
lat1=self.boston_d[1],
lon2=self.portland_d[0],
lat2=self.portland_d[1],
npts=10,
radians=False,
)
# Calculate 10 points between Boston and Portland in radians
points_r = self.g.npts(
lon1=self.boston_r[0],
lat1=self.boston_r[1],
lon2=self.portland_r[0],
lat2=self.portland_r[1],
npts=10,
radians=True,
)
# Check they are equal
for index, dpoint in enumerate(points_d):
self.assertAlmostEqual(dpoint[0], math.degrees(points_r[index][0]))
self.assertAlmostEqual(dpoint[1], math.degrees(points_r[index][1]))
class Geod_NaN_Issue112_Test(unittest.TestCase):
# Test for Issue #112; Geod should silently propagate NaNs in input
# to the output.
def test_geod_nans(self):
g = Geod(ellps="clrk66")
(azi1, azi2, s12) = g.inv(43, 10, float("nan"), 20)
self.assertTrue(azi1 != azi1)
self.assertTrue(azi2 != azi2)
self.assertTrue(s12 != s12)
(azi1, azi2, s12) = g.inv(43, 10, 53, float("nan"))
self.assertTrue(azi1 != azi1)
self.assertTrue(azi2 != azi2)
self.assertTrue(s12 != s12)
# Illegal latitude is treated as NaN
(azi1, azi2, s12) = g.inv(43, 10, 53, 91)
self.assertTrue(azi1 != azi1)
self.assertTrue(azi2 != azi2)
self.assertTrue(s12 != s12)
(lon2, lat2, azi2) = g.fwd(43, 10, float("nan"), 1e6)
self.assertTrue(lon2 != lon2)
self.assertTrue(lat2 != lat2)
self.assertTrue(azi2 != azi2)
(lon2, lat2, azi2) = g.fwd(43, 10, 20, float("nan"))
self.assertTrue(lon2 != lon2)
self.assertTrue(lat2 != lat2)
self.assertTrue(azi2 != azi2)
(lon2, lat2, azi2) = g.fwd(43, float("nan"), 20, 1e6)
self.assertTrue(lon2 != lon2)
self.assertTrue(lat2 != lat2)
self.assertTrue(azi2 != azi2)
# Illegal latitude is treated as NaN
(lon2, lat2, azi2) = g.fwd(43, 91, 20, 1e6)
self.assertTrue(lon2 != lon2)
self.assertTrue(lat2 != lat2)
self.assertTrue(azi2 != azi2)
# Only lon2 is NaN
(lon2, lat2, azi2) = g.fwd(float("nan"), 10, 20, 1e6)
self.assertTrue(lon2 != lon2)
self.assertTrue(lat2 == lat2)
self.assertTrue(azi2 == azi2)
def test_proj_equals():
assert Proj(4326) == Proj("epsg:4326")
assert Proj(4326) != Proj("epsg:3857")
with pytest.warns(UserWarning):
assert Proj(4326) == Proj(Proj("epsg:4326").crs.to_proj4())
def test_initialize_proj_crs_no_proj4():
proj = Proj(
{
"a": 6371229.0,
"b": 6371229.0,
"lon_0": -10.0,
"o_lat_p": 30.0,
"o_lon_p": 0.0,
"o_proj": "longlat",
"proj": "ob_tran",
}
)
assert proj.srs.startswith("+proj=ob_tran")
def test_initialize_proj_crs_no_plus():
proj = Proj("proj=lonlat")
assert proj.crs.srs == "proj=lonlat type=crs"
def test_initialize_projparams_with_kwargs():
proj_mixed_args = Proj("+proj=utm +zone=10", ellps="WGS84")
proj_positional = Proj("+proj=utm +zone=10 +ellps=WGS84")
assert proj_mixed_args.is_exact_same(proj_positional)
def test_equals_different_type():
assert Proj("epsg:4326") != ""
def test_is_exact_same_different_type():
assert not Proj("epsg:4326").is_exact_same(None)
def test_reset_errno():
proj = Proj(
{"proj": "laea", "lat_0": -90, "lon_0": 0, "a": 6371228.0, "units": "m"}
)
assert not proj.crs.is_geographic
assert proj(0, 0, inverse=True, errcheck=True) == (0.0, -90.0)
@pytest.mark.parametrize("radians", [False, True])
def test_get_factors__2d_input(radians):
transformer = Proj(3857)
longitude = numpy.array([[0, 1], [2, 3]])
latitude = numpy.array([[1, 2], [3, 4]])
if radians:
longitude = numpy.radians(longitude)
latitude = numpy.radians(latitude)
factors = transformer.get_factors(
longitude=longitude, latitude=latitude, radians=radians
)
assert_almost_equal(
factors.meridional_scale, [[1.0001523, 1.0006095], [1.0013723, 1.0024419]]
)
assert_almost_equal(
factors.parallel_scale, [[1.0001523, 1.0006095], [1.0013723, 1.0024419]]
)
assert_almost_equal(
factors.areal_scale, [[1.00030468, 1.00121946], [1.00274658, 1.00488976]]
)
assert_almost_equal(factors.angular_distortion, [[0, 0], [0, 0]], decimal=5)
assert_almost_equal(
factors.meridian_parallel_angle, [[89.99, 90], [90, 90]], decimal=2
)
assert_almost_equal(factors.meridian_convergence, [[0, 0], [0, 0]])
assert_almost_equal(
factors.tissot_semimajor, [[1.00015234, 1.00060955], [1.00137235, 1.0024419]]
)
assert_almost_equal(
factors.tissot_semiminor, [[1.00015232, 1.00060953], [1.00137235, 1.0024419]]
)
assert_almost_equal(factors.dx_dlam, [[1, 1], [1, 1]])
assert_almost_equal(factors.dx_dphi, [[0, 0], [0, 0]])
assert_almost_equal(factors.dy_dlam, [[0, 0], [0, 0]])
assert_almost_equal(
factors.dy_dphi, [[1.00015233, 1.00060954], [1.00137235, 1.0024419]]
)
def test_get_factors():
transformer = Proj(3717)
factors = transformer.get_factors(-120, 34)
assert_almost_equal(factors.meridional_scale, 1.0005466)
assert_almost_equal(factors.parallel_scale, 1.0005466)
assert_almost_equal(factors.areal_scale, 1.00109349)
assert_almost_equal(factors.angular_distortion, 0)
assert_almost_equal(factors.meridian_parallel_angle, 90)
assert_almost_equal(factors.meridian_convergence, 1.67864770)
assert_almost_equal(factors.tissot_semimajor, 1.00055, decimal=5)
assert_almost_equal(factors.tissot_semiminor, 1.00055, decimal=5)
assert_almost_equal(factors.dx_dlam, 0.8300039)
assert_almost_equal(factors.dx_dphi, -0.0292052)
assert_almost_equal(factors.dy_dlam, 0.0243244)
assert_almost_equal(factors.dy_dphi, 0.9965495)
def test_get_factors__nan_inf():
transformer = Proj(3857)
factors = transformer.get_factors(
longitude=[0, numpy.nan, numpy.inf, 0], latitude=[numpy.nan, 2, 2, numpy.inf]
)
assert_almost_equal(
factors.meridional_scale, [numpy.inf, numpy.inf, numpy.inf, numpy.inf]
)
assert_almost_equal(
factors.parallel_scale, [numpy.inf, numpy.inf, numpy.inf, numpy.inf]
)
assert_almost_equal(
factors.areal_scale, [numpy.inf, numpy.inf, numpy.inf, numpy.inf]
)
assert_almost_equal(
factors.angular_distortion, [numpy.inf, numpy.inf, numpy.inf, numpy.inf]
)
assert_almost_equal(
factors.meridian_parallel_angle, [numpy.inf, numpy.inf, numpy.inf, numpy.inf]
)
assert_almost_equal(
factors.meridian_convergence, [numpy.inf, numpy.inf, numpy.inf, numpy.inf]
)
assert_almost_equal(
factors.tissot_semimajor, [numpy.inf, numpy.inf, numpy.inf, numpy.inf]
)
assert_almost_equal(
factors.tissot_semiminor, [numpy.inf, numpy.inf, numpy.inf, numpy.inf]
)
assert_almost_equal(factors.dx_dlam, [numpy.inf, numpy.inf, numpy.inf, numpy.inf])
assert_almost_equal(factors.dx_dphi, [numpy.inf, numpy.inf, numpy.inf, numpy.inf])
assert_almost_equal(factors.dy_dlam, [numpy.inf, numpy.inf, numpy.inf, numpy.inf])
assert_almost_equal(factors.dy_dphi, [numpy.inf, numpy.inf, numpy.inf, numpy.inf])
def test_get_factors__errcheck():
transformer = Proj(3857)
with pytest.raises(ProjError):
transformer.get_factors(longitude=40, latitude=70, errcheck=True, radians=True)
def test_numpy_bool_kwarg_false():
# Issue 564
south = numpy.array(50) < 0
proj = Proj(
proj="utm", zone=32, ellipsis="WGS84", datum="WGS84", units="m", south=south
)
assert "south" not in proj.srs
def test_numpy_bool_kwarg_true():
# Issue 564
south = numpy.array(50) > 0
proj = Proj(
proj="utm", zone=32, ellipsis="WGS84", datum="WGS84", units="m", south=south
)
assert "+south " in proj.srs
@patch.dict("os.environ", {"PROJ_NETWORK": "ON"}, clear=True)
def test_network__disable():
with proj_network_env():
pyproj.network.set_network_enabled(active=False)
transformer = Proj(3857)
assert transformer.is_network_enabled is False
@patch.dict("os.environ", {"PROJ_NETWORK": "OFF"}, clear=True)
def test_network__enable():
with proj_network_env():
pyproj.network.set_network_enabled(active=True)
transformer = Proj(3857)
assert transformer.is_network_enabled is True
def test_network__default():
with proj_network_env():
pyproj.network.set_network_enabled()
transformer = Proj(3857)
assert transformer.is_network_enabled == (
os.environ.get("PROJ_NETWORK") == "ON"
)
def test_radians():
proj = Proj(
{"proj": "lcc", "R": 6371200, "lat_1": 50, "lat_2": 50, "lon_0": -107},
preserve_units=False,
)
assert_almost_equal(
proj(math.radians(-145.5), math.radians(1.0), radians=True),
(-5632642.22547495, 1636571.4883145525),
)
@pytest.mark.skipif(
pyproj._datadir._USE_GLOBAL_CONTEXT, reason="Global Context not Threadsafe."
)
def test_proj_multithread():
# https://github.com/pyproj4/pyproj/issues/782
trans = Proj("EPSG:3857")
def transform(num):
return trans(1, 2)
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
for result in executor.map(transform, range(10)):
pass
pyproj-3.6.1/test/test_show_versions.py 0000664 0000000 0000000 00000002175 14502715416 0020356 0 ustar 00root root 0000000 0000000 from pyproj._show_versions import (
_get_deps_info,
_get_proj_info,
_get_sys_info,
show_versions,
)
def test_get_proj_info():
pyproj_info = _get_proj_info()
assert "pyproj" in pyproj_info
assert "PROJ" in pyproj_info
assert "data dir" in pyproj_info
assert "user_data_dir" in pyproj_info
assert "PROJ DATA (recommended version)" in pyproj_info
assert "PROJ Database" in pyproj_info
assert "EPSG Database" in pyproj_info
assert "ESRI Database" in pyproj_info
assert "IGNF Database" in pyproj_info
def test_get_sys_info():
sys_info = _get_sys_info()
assert "python" in sys_info
assert "executable" in sys_info
assert "machine" in sys_info
def test_get_deps_info():
deps_info = _get_deps_info()
assert "pip" in deps_info
assert "setuptools" in deps_info
assert "certifi" in deps_info
assert "Cython" in deps_info
def test_show_versions_with_proj(capsys):
show_versions()
out, err = capsys.readouterr()
assert "System" in out
assert "python" in out
assert "PROJ" in out
assert "data dir" in out
assert "Python deps" in out
pyproj-3.6.1/test/test_sync.py 0000664 0000000 0000000 00000014371 14502715416 0016423 0 ustar 00root root 0000000 0000000 from datetime import datetime, timedelta
from unittest.mock import MagicMock, patch
from urllib.error import URLError
import pytest
from pyproj.aoi import BBox
from pyproj.sync import (
_download_resource_file,
_load_grid_geojson,
_sha256sum,
get_transform_grid_list,
)
@pytest.mark.network
def test_get_transform_grid_list():
grids = get_transform_grid_list(include_already_downloaded=True)
assert len(grids) > 200
@pytest.mark.network
def test_get_transform_grid_list__bbox__antimeridian():
grids = get_transform_grid_list(
bbox=BBox(170, -90, -170, 90), include_already_downloaded=True
)
assert len(grids) > 10
source_ids = set()
for grid in grids:
source_ids.add(grid["properties"]["source_id"])
assert sorted(source_ids) == [
"au_ga",
"nc_dittt",
"nz_linz",
"us_nga",
"us_noaa",
]
@pytest.mark.network
def test_get_transform_grid_list__bbox__out_of_bounds():
grids = get_transform_grid_list(
bbox=BBox(170, -90, 190, 90), include_already_downloaded=True
)
assert len(grids) > 10
source_ids = set()
for grid in grids:
source_ids.add(grid["properties"]["source_id"])
assert sorted(source_ids) == [
"au_ga",
"nc_dittt",
"nz_linz",
"us_nga",
"us_noaa",
]
@pytest.mark.network
def test_get_transform_grid_list__source_id():
grids = get_transform_grid_list(
bbox=BBox(170, -90, -170, 90),
source_id="us_noaa",
include_already_downloaded=True,
)
assert len(grids) > 5
source_ids = set()
for grid in grids:
source_ids.add(grid["properties"]["source_id"])
assert sorted(source_ids) == ["us_noaa"]
@pytest.mark.network
def test_get_transform_grid_list__contains():
grids = get_transform_grid_list(
bbox=BBox(170, -90, -170, 90),
spatial_test="contains",
include_already_downloaded=True,
)
assert len(grids) > 5
source_ids = set()
for grid in grids:
source_ids.add(grid["properties"]["source_id"])
assert sorted(source_ids) == ["nz_linz"]
@pytest.mark.network
def test_get_transform_grid_list__file():
grids = get_transform_grid_list(
filename="us_noaa_alaska", include_already_downloaded=True
)
assert len(grids) == 1
assert grids[0]["properties"]["name"] == "us_noaa_alaska.tif"
@pytest.mark.network
def test_get_transform_grid_list__area_of_use():
grids = get_transform_grid_list(area_of_use="USA", include_already_downloaded=True)
assert len(grids) > 10
for grid in grids:
assert "USA" in grid["properties"]["area_of_use"]
def test_sha256sum(tmp_path):
test_file = tmp_path / "test.file"
test_file.write_text("TEST")
assert (
_sha256sum(test_file)
== "94ee059335e587e501cc4bf90613e0814f00a7b08bc7c648fd865a2af6a22cc2"
)
@patch("pyproj.sync.urlretrieve", autospec=True)
@pytest.mark.parametrize("verbose", [True, False])
def test_download_resource_file(urlretrieve_mock, verbose, tmp_path, capsys):
def dummy_urlretrieve(url, local_path):
with open(local_path, "w") as testf:
testf.write("TEST")
urlretrieve_mock.side_effect = dummy_urlretrieve
_download_resource_file(
file_url="test_url",
short_name="test_file.txt",
directory=tmp_path,
verbose=verbose,
sha256="94ee059335e587e501cc4bf90613e0814f00a7b08bc7c648fd865a2af6a22cc2",
)
urlretrieve_mock.assert_called_with("test_url", tmp_path / "test_file.txt.part")
captured = capsys.readouterr()
if not verbose:
assert captured.out == ""
else:
assert captured.out == "Downloading: test_url\n"
expected_file = tmp_path / "test_file.txt"
assert expected_file.exists()
assert (
_sha256sum(expected_file)
== "94ee059335e587e501cc4bf90613e0814f00a7b08bc7c648fd865a2af6a22cc2"
)
@patch("pyproj.sync.urlretrieve", autospec=True)
def test_download_resource_file__nosha256(urlretrieve_mock, tmp_path):
def dummy_urlretrieve(url, local_path):
local_path.touch()
urlretrieve_mock.side_effect = dummy_urlretrieve
_download_resource_file(
file_url="test_url", short_name="test_file.txt", directory=tmp_path
)
urlretrieve_mock.assert_called_with("test_url", tmp_path / "test_file.txt.part")
expected_file = tmp_path / "test_file.txt"
assert expected_file.exists()
@patch("pyproj.sync.urlretrieve", autospec=True)
def test_download_resource_file__exception(urlretrieve_mock, tmp_path):
def dummy_urlretrieve(url, local_path):
local_path.touch()
raise URLError("Test")
urlretrieve_mock.side_effect = dummy_urlretrieve
with pytest.raises(URLError):
_download_resource_file(
file_url="test_url",
short_name="test_file.txt",
directory=str(tmp_path),
verbose=False,
sha256="test",
)
urlretrieve_mock.assert_called_with("test_url", tmp_path / "test_file.txt.part")
assert not tmp_path.joinpath("test_file.txt.part").exists()
assert not tmp_path.joinpath("test_file.txt").exists()
@patch("pyproj.sync.urlretrieve", autospec=True)
def test_download_resource_file__bad_sha256sum(urlretrieve_mock, tmp_path):
def dummy_urlretrieve(url, local_path):
local_path.touch()
urlretrieve_mock.side_effect = dummy_urlretrieve
with pytest.raises(RuntimeError, match="SHA256 mismatch: test_file.txt"):
_download_resource_file(
file_url="test_url",
short_name="test_file.txt",
directory=tmp_path,
verbose=False,
sha256="test",
)
urlretrieve_mock.assert_called_with("test_url", tmp_path / "test_file.txt.part")
assert not tmp_path.joinpath("test_file.txt.part").exists()
assert not tmp_path.joinpath("test_file.txt").exists()
@pytest.mark.network
@patch("pyproj.sync.Path.stat")
def test__load_grid_geojson_old_file(stat_mock, tmp_path):
return_timestamp = MagicMock()
return_timestamp.st_mtime = (datetime.utcnow() - timedelta(days=2)).timestamp()
stat_mock.return_value = return_timestamp
tmp_path.joinpath("files.geojson").touch()
grids = _load_grid_geojson(target_directory=tmp_path)
assert sorted(grids) == ["features", "name", "type"]
pyproj-3.6.1/test/test_transform.py 0000664 0000000 0000000 00000013547 14502715416 0017466 0 ustar 00root root 0000000 0000000 import numpy
import pytest
from numpy.testing import assert_allclose, assert_almost_equal
from pyproj import Proj, __proj_version__, transform
from test.conftest import PROJ_911, PROJ_GTE_92, PROJ_GTE_911, grids_available
def test_transform():
# convert awips221 grid to awips218 coordinate system
# (grids defined at http://www.nco.ncep.noaa.gov/pmb/docs/on388/tableb.html)
nx = 614
ny = 428
dx = 12190.58
dy = dx
awips221 = Proj(proj="lcc", R=6371200, lat_1=50, lat_2=50, lon_0=-107)
print("proj4 library version = ", __proj_version__)
llcrnrx, llcrnry = awips221(-145.5, 1)
awips221 = Proj(
proj="lcc",
R=6371200,
lat_1=50,
lat_2=50,
lon_0=-107,
x_0=-llcrnrx,
y_0=-llcrnry,
)
assert_allclose(awips221(-145.5, 1), (0, 0), atol=1e-4)
awips218 = Proj(proj="lcc", R=6371200, lat_1=25, lat_2=25, lon_0=-95)
llcrnrx, llcrnry = awips218(-133.459, 12.19)
awips218 = Proj(
proj="lcc", R=6371200, lat_1=25, lat_2=25, lon_0=-95, x_0=-llcrnrx, y_0=-llcrnry
)
assert_allclose(awips218(-133.459, 12.19), (0, 0), atol=1e-4)
x1 = dx * numpy.indices((ny, nx), "f")[1, :, :]
y1 = dy * numpy.indices((ny, nx), "f")[0, :, :]
print("max/min x and y for awips218 grid")
print(numpy.minimum.reduce(numpy.ravel(x1)), numpy.maximum.reduce(numpy.ravel(x1)))
print(numpy.minimum.reduce(numpy.ravel(y1)), numpy.maximum.reduce(numpy.ravel(y1)))
with pytest.warns(FutureWarning):
x2, y2 = transform(awips218, awips221, x1, y1)
print("max/min x and y for awips218 grid in awips221 coordinates")
print(numpy.minimum.reduce(numpy.ravel(x2)), numpy.maximum.reduce(numpy.ravel(x2)))
print(numpy.minimum.reduce(numpy.ravel(y2)), numpy.maximum.reduce(numpy.ravel(y2)))
with pytest.warns(FutureWarning):
x3, y3 = transform(awips221, awips218, x2, y2)
print("error for reverse transformation back to awips218 coords")
print("(should be close to zero)")
assert_allclose(numpy.minimum.reduce(numpy.ravel(x3 - x1)), 0, atol=1e-4)
assert_allclose(numpy.maximum.reduce(numpy.ravel(x3 - x1)), 0, atol=1e-4)
assert_allclose(numpy.minimum.reduce(numpy.ravel(y3 - y1)), 0, atol=1e-4)
assert_allclose(numpy.maximum.reduce(numpy.ravel(y3 - y1)), 0, atol=1e-4)
@pytest.mark.xfail(PROJ_911, reason="Patch applied in conda-forge changes behavior")
def test_transform_single_point_nad83_to_nad27():
# projection 1: UTM zone 15, grs80 ellipse, NAD83 datum
# (defined by epsg code 26915)
p1 = Proj("epsg:26915", preserve_units=False)
# projection 2: UTM zone 15, clrk66 ellipse, NAD27 datum
p2 = Proj("epsg:26715", preserve_units=False)
# find x,y of Jefferson City, MO.
x1, y1 = p1(-92.199881, 38.56694)
# transform this point to projection 2 coordinates.
x2, y2 = transform(p1, p2, x1, y1)
assert_almost_equal(
(x1, y1),
(569704.566, 4269024.671),
decimal=3,
)
expected_xy2 = (569722, 4268814)
if PROJ_GTE_911:
expected_xy2 = (569720, 4268813)
if (
PROJ_GTE_92
and grids_available(
"us_noaa_nadcon5_nad27_nad83_1986_conus.tif", check_network=False
)
) or grids_available():
expected_xy2 = (569722, 4268814)
elif grids_available(
"ca_nrc_ntv2_0.tif", "ca_nrc_ntv1_can.tif", check_network=False
):
expected_xy2 = (569706, 4268817)
elif grids_available("us_noaa_conus.tif", check_network=False):
expected_xy2 = (569722, 4268814)
assert_almost_equal(
(x2, y2),
expected_xy2,
decimal=0,
)
assert_almost_equal(
p2(x2, y2, inverse=True, errcheck=True),
(-92.200, 38.567),
decimal=3,
)
@pytest.mark.xfail(PROJ_911, reason="Patch applied in conda-forge changes behavior")
def test_transform_tuple_nad83_to_nad27():
# projection 1: UTM zone 15, grs80 ellipse, NAD83 datum
# (defined by epsg code 26915)
p1 = Proj("epsg:26915", preserve_units=False)
# projection 2: UTM zone 15, clrk66 ellipse, NAD27 datum
p2 = Proj("epsg:26715", preserve_units=False)
# process 3 points at a time in a tuple
lats = (38.83, 39.32, 38.75) # Columbia, KC and StL Missouri
lons = (-92.22, -94.72, -90.37)
x1, y1 = p1(lons, lats)
x2, y2 = transform(p1, p2, x1, y1)
assert_almost_equal(
x1,
(567703.344, 351730.944, 728553.093),
decimal=3,
)
assert_almost_equal(
y1,
(4298200.739, 4353698.725, 4292319.005),
decimal=3,
)
expected_x2 = (567721, 351747, 728569)
expected_y2 = (4297989, 4353489, 4292106)
if PROJ_GTE_911:
expected_x2 = (567719, 351748, 728568)
expected_y2 = (4297989, 4353487, 4292108)
if (
PROJ_GTE_92
and grids_available(
"us_noaa_nadcon5_nad27_nad83_1986_conus.tif", check_network=False
)
) or grids_available():
expected_x2 = (567721, 351747, 728569)
expected_y2 = (4297989, 4353489, 4292106)
elif grids_available(
"ca_nrc_ntv2_0.tif", "ca_nrc_ntv1_can.tif", check_network=False
):
expected_x2 = (567705, 351727, 728558)
expected_y2 = (4297993, 4353490, 4292111)
elif grids_available("us_noaa_conus.tif", check_network=False):
expected_x2 = (567721, 351747, 728569.133)
expected_y2 = (4297989, 4353489, 4292106)
assert_almost_equal(
x2,
expected_x2,
decimal=0,
)
assert_almost_equal(
y2,
expected_y2,
decimal=0,
)
lons2, lats2 = p2(x2, y2, inverse=True, errcheck=True)
assert_almost_equal(
lons2,
(-92.220, -94.720, -90.370),
decimal=3,
)
assert_almost_equal(
lats2,
(38.830, 39.320, 38.750),
decimal=3,
)
pyproj-3.6.1/test/test_transformer.py 0000664 0000000 0000000 00000157005 14502715416 0020013 0 ustar 00root root 0000000 0000000 import concurrent.futures
import os
import pickle
from array import array
from contextlib import nullcontext
from functools import partial
from glob import glob
from itertools import permutations
from pathlib import Path
from unittest.mock import call, patch
import numpy
import pytest
from numpy.testing import assert_almost_equal, assert_array_equal
import pyproj
from pyproj import CRS, Proj, Transformer, itransform, transform
from pyproj.datadir import append_data_dir
from pyproj.enums import TransformDirection
from pyproj.exceptions import ProjError
from pyproj.transformer import AreaOfInterest, TransformerGroup
from test.conftest import (
PROJ_GTE_91,
PROJ_GTE_92,
PROJ_GTE_93,
grids_available,
proj_env,
proj_network_env,
)
def test_tranform_wgs84_to_custom():
custom_proj = pyproj.Proj(
"+proj=geos +lon_0=0.000000 +lat_0=0 +h=35807.414063"
" +a=6378.169000 +b=6356.583984"
)
wgs84 = pyproj.Proj("+proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs")
lat, lon = 51.04715, 3.23406
with pytest.warns(FutureWarning):
xx, yy = pyproj.transform(wgs84, custom_proj, lon, lat)
assert f"{xx:.3f} {yy:.3f}" == "212.623 4604.975"
@pytest.mark.grid
def test_transform_wgs84_to_alaska():
with pytest.warns(FutureWarning):
lat_lon_proj = pyproj.Proj(init="epsg:4326", preserve_units=False)
alaska_aea_proj = pyproj.Proj(init="epsg:2964", preserve_units=False)
test = (-179.72638, 49.752533)
with pytest.warns(FutureWarning):
xx, yy = pyproj.transform(lat_lon_proj, alaska_aea_proj, *test)
if grids_available("us_noaa_alaska.tif"):
assert f"{xx:.3f} {yy:.3f}" == "-1824924.495 330822.800"
else:
assert f"{xx:.3f} {yy:.3f}" == "-1825155.697 330730.391"
@pytest.mark.skip(reason="https://github.com/OSGeo/PROJ/issues/2425")
def test_illegal_transformation():
# issue 202
with pytest.warns(FutureWarning):
p1 = pyproj.Proj(init="epsg:4326")
p2 = pyproj.Proj(init="epsg:3857")
with pytest.warns(FutureWarning):
xx, yy = pyproj.transform(
p1, p2, (-180, -180, 180, 180, -180), (-90, 90, 90, -90, -90)
)
assert numpy.all(numpy.isinf(xx))
assert numpy.all(numpy.isinf(yy))
with pytest.warns(FutureWarning), pytest.raises(ProjError):
pyproj.transform(
p1, p2, (-180, -180, 180, 180, -180), (-90, 90, 90, -90, -90), errcheck=True
)
def test_lambert_conformal_transform():
# issue 207
with pytest.warns(FutureWarning):
Midelt = pyproj.Proj(init="epsg:26191")
WGS84 = pyproj.Proj(init="epsg:4326")
E = 567623.931
N = 256422.787
h = 1341.467
with pytest.warns(FutureWarning):
Long1, Lat1, H1 = pyproj.transform(Midelt, WGS84, E, N, h, radians=False)
assert_almost_equal((Long1, Lat1, H1), (-4.6753456, 32.902199, 1341.467), decimal=5)
def test_4d_transform(scalar_and_array):
transformer = Transformer.from_pipeline("+init=ITRF2008:ITRF2000")
assert_almost_equal(
transformer.transform(
xx=scalar_and_array(3513638.19380),
yy=scalar_and_array(778956.45250),
zz=scalar_and_array(5248216.46900),
tt=scalar_and_array(2008.75),
),
(
scalar_and_array(3513638.1999428216),
scalar_and_array(778956.4532640711),
scalar_and_array(5248216.453456361),
scalar_and_array(2008.75),
),
)
def test_2d_with_time_transform(scalar_and_array):
transformer = Transformer.from_pipeline("+init=ITRF2008:ITRF2000")
assert_almost_equal(
transformer.transform(
xx=scalar_and_array(3513638.19380),
yy=scalar_and_array(778956.45250),
tt=scalar_and_array(2008.75),
),
(
scalar_and_array(3513638.1999428216),
scalar_and_array(778956.4532640711),
scalar_and_array(2008.75),
),
)
def test_4d_transform_crs_obs1(scalar_and_array):
transformer = Transformer.from_proj(7789, 8401)
assert_almost_equal(
transformer.transform(
xx=scalar_and_array(3496737.2679),
yy=scalar_and_array(743254.4507),
zz=scalar_and_array(5264462.9620),
tt=scalar_and_array(2019.0),
),
(
scalar_and_array(3496737.757717311),
scalar_and_array(743253.9940103051),
scalar_and_array(5264462.701132784),
scalar_and_array(2019.0),
),
)
def test_4d_transform_orginal_crs_obs1():
with pytest.warns(FutureWarning):
assert_almost_equal(
transform(
7789, 8401, x=3496737.2679, y=743254.4507, z=5264462.9620, tt=2019.0
),
(3496737.757717311, 743253.9940103051, 5264462.701132784, 2019.0),
)
def test_4d_transform_crs_obs2(scalar_and_array):
transformer = Transformer.from_proj(4896, 7930)
assert_almost_equal(
transformer.transform(
xx=scalar_and_array(3496737.2679),
yy=scalar_and_array(743254.4507),
zz=scalar_and_array(5264462.9620),
tt=scalar_and_array(2019.0),
),
(
scalar_and_array(3496737.7857162016),
scalar_and_array(743254.0394113371),
scalar_and_array(5264462.643659916),
scalar_and_array(2019.0),
),
)
def test_2d_with_time_transform_crs_obs2(scalar_and_array):
transformer = Transformer.from_proj(4896, 7930)
assert_almost_equal(
transformer.transform(
xx=scalar_and_array(3496737.2679),
yy=scalar_and_array(743254.4507),
tt=scalar_and_array(2019.0),
),
(
scalar_and_array(3496737.4105305015),
scalar_and_array(743254.1014318303),
scalar_and_array(2019.0),
),
)
def test_2d_with_time_transform_original_crs_obs2():
with pytest.warns(FutureWarning):
assert_almost_equal(
transform(4896, 7930, x=3496737.2679, y=743254.4507, tt=2019.0),
(3496737.4105305015, 743254.1014318303, 2019.0),
)
def test_4d_itransform():
transformer = Transformer.from_pipeline("+init=ITRF2008:ITRF2000")
assert_almost_equal(
list(
transformer.itransform(
[(3513638.19380, 778956.45250, 5248216.46900, 2008.75)]
)
),
[(3513638.1999428216, 778956.4532640711, 5248216.453456361, 2008.75)],
)
def test_3d_time_itransform():
transformer = Transformer.from_pipeline("+init=ITRF2008:ITRF2000")
assert_almost_equal(
list(
transformer.itransform(
[(3513638.19380, 778956.45250, 2008.75)], time_3rd=True
)
),
[(3513638.1999428216, 778956.4532640711, 2008.75)],
)
def test_4d_itransform_orginal_crs_obs1():
with pytest.warns(FutureWarning):
assert_almost_equal(
list(
itransform(
7789, 8401, [(3496737.2679, 743254.4507, 5264462.9620, 2019.0)]
)
),
[(3496737.757717311, 743253.9940103051, 5264462.701132784, 2019.0)],
)
def test_2d_with_time_itransform_original_crs_obs2():
with pytest.warns(FutureWarning):
assert_almost_equal(
list(
itransform(
4896, 7930, [(3496737.2679, 743254.4507, 2019.0)], time_3rd=True
)
),
[(3496737.4105305015, 743254.1014318303, 2019.0)],
)
def test_itransform_time_3rd_invalid():
with pytest.warns(FutureWarning), pytest.raises(
ValueError, match="'time_3rd' is only valid for 3 coordinates."
):
list(
itransform(
7789,
8401,
[(3496737.2679, 743254.4507, 5264462.9620, 2019.0)],
time_3rd=True,
)
)
with pytest.warns(FutureWarning), pytest.raises(
ValueError, match="'time_3rd' is only valid for 3 coordinates."
):
list(itransform(7789, 8401, [(3496737.2679, 743254.4507)], time_3rd=True))
def test_transform_no_error():
with pytest.warns(FutureWarning):
pj = Proj(init="epsg:4555")
pjx, pjy = pj(116.366, 39.867)
with pytest.warns(FutureWarning):
transform(pj, Proj(4326), pjx, pjy, radians=True, errcheck=True)
def test_itransform_no_error():
with pytest.warns(FutureWarning):
pj = Proj(init="epsg:4555")
pjx, pjy = pj(116.366, 39.867)
with pytest.warns(FutureWarning):
list(itransform(pj, Proj(4326), [(pjx, pjy)], radians=True, errcheck=True))
def test_transform_no_exception():
# issue 249
with pytest.warns(FutureWarning):
transformer = Transformer.from_proj("+init=epsg:4326", "+init=epsg:27700")
transformer.transform(1.716073972, 52.658007833, errcheck=True)
transformer.itransform([(1.716073972, 52.658007833)], errcheck=True)
def test_transform__out_of_bounds(scalar_and_array):
with pytest.warns(FutureWarning):
transformer = Transformer.from_proj("+init=epsg:4326", "+init=epsg:27700")
with pytest.raises(pyproj.exceptions.ProjError):
transformer.transform(
scalar_and_array(100000), scalar_and_array(100000), errcheck=True
)
def test_transform_radians():
with pytest.warns(FutureWarning):
WGS84 = pyproj.Proj("+init=EPSG:4326")
ECEF = pyproj.Proj(proj="geocent", ellps="WGS84", datum="WGS84")
with pytest.warns(FutureWarning):
assert_almost_equal(
pyproj.transform(
ECEF, WGS84, -2704026.010, -4253051.810, 3895878.820, radians=True
),
(-2.137113493845668, 0.6613203738996222, -20.531156923621893),
)
assert_almost_equal(
pyproj.transform(
WGS84,
ECEF,
-2.137113493845668,
0.6613203738996222,
-20.531156923621893,
radians=True,
),
(-2704026.010, -4253051.810, 3895878.820),
)
def test_itransform_radians():
with pytest.warns(FutureWarning):
WGS84 = pyproj.Proj("+init=EPSG:4326")
ECEF = pyproj.Proj(proj="geocent", ellps="WGS84", datum="WGS84")
with pytest.warns(FutureWarning):
assert_almost_equal(
list(
pyproj.itransform(
ECEF,
WGS84,
[(-2704026.010, -4253051.810, 3895878.820)],
radians=True,
)
),
[(-2.137113493845668, 0.6613203738996222, -20.531156923621893)],
)
assert_almost_equal(
list(
pyproj.itransform(
WGS84,
ECEF,
[(-2.137113493845668, 0.6613203738996222, -20.531156923621893)],
radians=True,
)
),
[(-2704026.010, -4253051.810, 3895878.820)],
)
def test_4d_transform__inverse(scalar_and_array):
transformer = Transformer.from_pipeline("+init=ITRF2008:ITRF2000")
assert_almost_equal(
transformer.transform(
xx=scalar_and_array(3513638.1999428216),
yy=scalar_and_array(778956.4532640711),
zz=scalar_and_array(5248216.453456361),
tt=scalar_and_array(2008.75),
direction=TransformDirection.INVERSE,
),
(
scalar_and_array(3513638.19380),
scalar_and_array(778956.45250),
scalar_and_array(5248216.46900),
scalar_and_array(2008.75),
),
)
def test_transform_direction(scalar_and_array):
forward_transformer = Transformer.from_crs(4326, 3857)
inverse_transformer = Transformer.from_crs(3857, 4326)
assert_array_equal(
inverse_transformer.transform(
scalar_and_array(-33),
scalar_and_array(24),
direction=TransformDirection.INVERSE,
),
forward_transformer.transform(scalar_and_array(-33), scalar_and_array(24)),
)
ident_transformer = Transformer.from_crs(4326, 3857)
assert_array_equal(
ident_transformer.transform(
scalar_and_array(-33),
scalar_and_array(24),
direction=TransformDirection.IDENT,
),
(scalar_and_array(-33), scalar_and_array(24)),
)
def test_always_xy__transformer(scalar_and_array):
transformer = Transformer.from_crs(2193, 4326, always_xy=True)
assert_almost_equal(
transformer.transform(scalar_and_array(1625350), scalar_and_array(5504853)),
(
scalar_and_array(173.29964730317386),
scalar_and_array(-40.60674802693758),
),
)
def test_always_xy__transform():
with pytest.warns(FutureWarning):
assert_almost_equal(
transform(2193, 4326, 1625350, 5504853, always_xy=True),
(173.29964730317386, -40.60674802693758),
)
def test_always_xy__itransform():
with pytest.warns(FutureWarning):
assert_almost_equal(
list(itransform(2193, 4326, [(1625350, 5504853)], always_xy=True)),
[(173.29964730317386, -40.60674802693758)],
)
@pytest.mark.parametrize("empty_array", [(), [], numpy.array([])])
def test_transform_empty_array_xy(empty_array):
transformer = Transformer.from_crs(2193, 4326)
assert_array_equal(
transformer.transform(empty_array, empty_array), (empty_array, empty_array)
)
@pytest.mark.parametrize("empty_array", [(), [], numpy.array([])])
def test_transform_empty_array_xyzt(empty_array):
transformer = Transformer.from_pipeline("+init=ITRF2008:ITRF2000")
assert_array_equal(
transformer.transform(empty_array, empty_array, empty_array, empty_array),
(empty_array, empty_array, empty_array, empty_array),
)
def test_transform_direction__string(scalar_and_array):
forward_transformer = Transformer.from_crs(4326, 3857)
inverse_transformer = Transformer.from_crs(3857, 4326)
assert_array_equal(
inverse_transformer.transform(
scalar_and_array(-33), scalar_and_array(24), direction="INVERSE"
),
forward_transformer.transform(
scalar_and_array(-33), scalar_and_array(24), direction="FORWARD"
),
)
ident_transformer = Transformer.from_crs(4326, 3857)
assert_array_equal(
ident_transformer.transform(
scalar_and_array(-33), scalar_and_array(24), direction="IDENT"
),
(scalar_and_array(-33), scalar_and_array(24)),
)
def test_transform_direction__string_lowercase(scalar_and_array):
forward_transformer = Transformer.from_crs(4326, 3857)
inverse_transformer = Transformer.from_crs(3857, 4326)
assert_array_equal(
inverse_transformer.transform(
scalar_and_array(-33), scalar_and_array(24), direction="inverse"
),
forward_transformer.transform(
scalar_and_array(-33), scalar_and_array(24), direction="forward"
),
)
ident_transformer = Transformer.from_crs(4326, 3857)
assert_array_equal(
ident_transformer.transform(
scalar_and_array(-33), scalar_and_array(24), direction="ident"
),
(scalar_and_array(-33), scalar_and_array(24)),
)
def test_transform_direction__invalid(scalar_and_array):
transformer = Transformer.from_crs(4326, 3857)
with pytest.raises(ValueError, match="Invalid value"):
transformer.transform(
scalar_and_array(-33), scalar_and_array(24), direction="WHEREVER"
)
def test_from_pipeline__non_transform_input():
with pytest.raises(ProjError, match="Input is not a transformation"):
Transformer.from_pipeline("epsg:4326")
def test_non_supported_initialization():
with pytest.raises(ProjError, match="Transformer must be initialized using"):
Transformer()
def test_pj_info_properties():
transformer = Transformer.from_crs(4326, 3857)
assert transformer.name == "pipeline"
assert transformer.description == "Popular Visualisation Pseudo-Mercator"
assert transformer.definition.startswith("proj=pipeline")
assert transformer.has_inverse
assert transformer.accuracy == 0
def test_to_proj4():
transformer = Transformer.from_crs(4326, 3857)
proj_string = transformer.to_proj4()
assert "+proj=pipeline" in proj_string
assert "\n" not in proj_string
def test_to_proj4__pretty():
transformer = Transformer.from_crs(4326, 3857)
proj_string = transformer.to_proj4(pretty=True)
assert "+proj=pipeline" in proj_string
assert "\n" in proj_string
def test_to_wkt():
transformer = Transformer.from_crs(4326, 3857)
assert transformer.to_wkt().startswith(
'CONVERSION["Popular Visualisation Pseudo-Mercator"'
)
def test_str():
assert str(Transformer.from_crs(4326, 3857)).startswith("proj=pipeline")
def test_repr():
assert repr(Transformer.from_crs(4326, 3857)) == (
"\n"
"Description: Popular Visualisation Pseudo-Mercator\n"
"Area of Use:\n"
"- name: World.\n"
"- bounds: (-180.0, -90.0, 180.0, 90.0)"
)
@pytest.mark.grid
def test_repr__conditional():
trans_repr = repr(Transformer.from_crs("EPSG:4326+3855", "EPSG:4979"))
if grids_available("us_nga_egm08_25.tif"):
assert trans_repr == (
"\n"
"Description: unavailable until proj_trans is called\n"
"Area of Use:\n- undefined"
)
elif PROJ_GTE_92 and not PROJ_GTE_93:
assert trans_repr == (
"\n"
"Description: Transformation from EGM2008 height to WGS 84 "
"(ballpark vertical transformation, without ellipsoid height "
"to vertical height correction)\n"
"Area of Use:\n- undefined"
)
else:
assert trans_repr == (
"\n"
"Description: Transformation from EGM2008 height to WGS 84 "
"(ballpark vertical transformation, without ellipsoid height "
"to vertical height correction)\n"
"Area of Use:\n"
f"- name: World{'.' if PROJ_GTE_93 else ''}\n"
"- bounds: (-180.0, -90.0, 180.0, 90.0)"
)
def test_to_json_dict():
transformer = Transformer.from_crs(4326, 3857)
json_dict = transformer.to_json_dict()
assert json_dict["type"] == "Conversion"
def test_to_json():
transformer = Transformer.from_crs(4326, 3857)
json_data = transformer.to_json()
assert "Conversion" in json_data
assert "\n" not in json_data
def test_to_json__pretty():
transformer = Transformer.from_crs(4326, 3857)
json_data = transformer.to_json(pretty=True)
assert "Conversion" in json_data
assert json_data.startswith('{\n "')
def test_to_json__pretty__indenation():
transformer = Transformer.from_crs(4326, 3857)
json_data = transformer.to_json(pretty=True, indentation=4)
assert "Conversion" in json_data
assert json_data.startswith('{\n "')
def test_transformer__operations():
transformer = TransformerGroup(28356, 7856).transformers[0]
assert [op.name for op in transformer.operations] == [
"Inverse of Map Grid of Australia zone 56",
"GDA94 to GDA2020 (1)",
"Map Grid of Australia zone 56",
]
def test_transformer__operations_missing():
assert Transformer.from_crs(7789, 8401).operations == ()
def test_transformer__operations__scope_remarks():
transformer = TransformerGroup(28356, 7856).transformers[0]
assert transformer.scope is None
assert [op.scope for op in transformer.operations] == [
"Engineering survey, topographic mapping.",
"Transformation of GDA94 coordinates that have been derived "
"through GNSS CORS.",
"Engineering survey, topographic mapping.",
]
assert [str(op.remarks)[:5].strip() for op in transformer.operations] == [
"Grid",
"Scale",
"Grid",
]
@pytest.mark.grid
def test_transformer__only_best():
with nullcontext() if PROJ_GTE_92 else pytest.raises(
NotImplementedError, match="only_best requires PROJ 9.2"
):
transformer = Transformer.from_crs(4326, 2964, only_best=True)
if not grids_available("ca_nrc_ntv2_0.tif"):
with pytest.raises(
ProjError,
match="Grid ca_nrc_ntv2_0.tif is not available.",
):
transformer.transform(60, -100, errcheck=True)
def test_transformer_group():
trans_group = TransformerGroup(7789, 8401)
assert len(trans_group.transformers) == 2
assert trans_group.transformers[0].name == "helmert"
assert trans_group.transformers[1].description == ("ITRF2014 to ETRF2014 (1)")
assert not trans_group.unavailable_operations
assert trans_group.best_available
@pytest.mark.grid
def test_transformer_group__unavailable():
trans_group = TransformerGroup(4326, 2964)
for transformer in trans_group.transformers:
assert transformer.is_network_enabled == (
os.environ.get("PROJ_NETWORK") == "ON"
)
if grids_available("us_noaa_alaska.tif", "ca_nrc_ntv2_0.tif", check_all=True):
assert len(trans_group.unavailable_operations) == 0
assert len(trans_group.transformers) == 10
assert (
trans_group.transformers[0].description
== "Inverse of NAD27 to WGS 84 (85) + Alaska Albers"
)
assert trans_group.best_available
elif grids_available("us_noaa_alaska.tif"):
assert len(trans_group.unavailable_operations) == 1
assert (
trans_group.transformers[0].description
== "Inverse of NAD27 to WGS 84 (85) + Alaska Albers"
)
assert len(trans_group.transformers) == 9
assert trans_group.best_available
elif grids_available("ca_nrc_ntv2_0.tif"):
assert len(trans_group.unavailable_operations) == 1
assert (
trans_group.transformers[0].description
== "Inverse of NAD27 to WGS 84 (7) + Alaska Albers"
)
assert len(trans_group.transformers) == 9
assert not trans_group.best_available
else:
assert len(trans_group.unavailable_operations) == 2
assert (
trans_group.unavailable_operations[0].name
== "Inverse of NAD27 to WGS 84 (85) + Alaska Albers"
)
assert len(trans_group.transformers) == 8
assert not trans_group.best_available
@pytest.mark.grid
def test_transform_group__missing_best():
with pytest.warns(FutureWarning):
lat_lon_proj = pyproj.Proj(init="epsg:4326", preserve_units=False)
alaska_aea_proj = pyproj.Proj(init="epsg:2964", preserve_units=False)
if not grids_available("ca_nrc_ntv2_0.tif"):
with pytest.warns(
UserWarning,
match="Best transformation is not available due to missing Grid",
):
trans_group = pyproj.transformer.TransformerGroup(
lat_lon_proj.crs, alaska_aea_proj.crs
)
assert not trans_group.best_available
assert "ntv2_0" not in trans_group.transformers[0].definition
assert "ntv2_0" in trans_group.unavailable_operations[0].to_proj4()
else:
# assuming all grids available or PROJ_NETWORK=ON
trans_group = pyproj.transformer.TransformerGroup(
lat_lon_proj.crs, alaska_aea_proj.crs
)
assert trans_group.best_available
assert "ntv2_0" in trans_group.transformers[0].definition
@pytest.mark.grid
def test_transform_group__area_of_interest():
def get_transformer_group():
return pyproj.transformer.TransformerGroup(
4326,
2964,
area_of_interest=pyproj.transformer.AreaOfInterest(
-136.46, 49.0, -60.72, 83.17
),
)
if not grids_available("ca_nrc_ntv2_0.tif"):
with pytest.warns(
UserWarning,
match="Best transformation is not available due to missing Grid",
):
trans_group = get_transformer_group()
assert (
trans_group.transformers[0].description
== "Inverse of NAD27 to WGS 84 (13) + Alaska Albers"
)
else:
trans_group = get_transformer_group()
assert trans_group.best_available
assert (
trans_group.transformers[0].description
== "Inverse of NAD27 to WGS 84 (33) + Alaska Albers"
)
@pytest.mark.grid
def test_transformer_group__get_transform_crs():
tg = TransformerGroup("epsg:4258", "epsg:7415")
if grids_available(
"nl_nsgi_nlgeo2018.tif", "nl_nsgi_rdtrans2018.tif", check_all=True
):
if PROJ_GTE_91:
assert len(tg.transformers) == 2
else:
assert len(tg.transformers) == 6
elif not PROJ_GTE_91 and grids_available("nl_nsgi_rdtrans2018.tif"):
assert len(tg.transformers) == 2
elif not PROJ_GTE_91 and grids_available("nl_nsgi_nlgeo2018.tif"):
assert len(tg.transformers) == 4
else:
assert len(tg.transformers) == 1
def test_transformer__area_of_interest():
transformer = Transformer.from_crs(
"EPSG:7789",
"EPSG:4936",
area_of_interest=AreaOfInterest(-177.25, -44.64, -43.3, -175.54),
)
assert (
transformer.description
== "Ballpark geocentric translation from ITRF2014 to ETRS89"
)
def test_transformer_proj__area_of_interest():
transformer = Transformer.from_proj(
"EPSG:7789",
"EPSG:4936",
area_of_interest=AreaOfInterest(-177.25, -44.64, -43.3, -175.54),
)
assert (
transformer.description
== "Ballpark geocentric translation from ITRF2014 to ETRS89"
)
def test_transformer__area_of_interest__invalid():
with pytest.raises(ProjError):
Transformer.from_crs(
4326, 2964, area_of_interest=(-136.46, 49.0, -60.72, 83.17)
)
def test_transformer_group__area_of_interest__invalid():
with pytest.raises(ProjError):
TransformerGroup(4326, 2964, area_of_interest=(-136.46, 49.0, -60.72, 83.17))
def test_transformer_equals():
assert (
TransformerGroup(28356, 7856).transformers[0]
== TransformerGroup(28356, 7856).transformers[0]
)
@pytest.mark.parametrize(
"comparison",
[Transformer.from_pipeline("+proj=pipeline +ellps=GRS80 +step +proj=cart"), 22],
)
def test_transformer_not_equals(comparison):
assert Transformer.from_crs(28356, 7856) != comparison
@pytest.mark.parametrize(
"pipeline_str",
[
"+proj=pipeline +ellps=GRS80 +step +proj=cart",
"+proj=pipeline +step +proj=unitconvert +xy_in=deg "
"+xy_out=rad +ellps=GRS80 +step +proj=cart",
],
)
def test_pipeline_transform(pipeline_str):
trans = Transformer.from_pipeline(pipeline_str)
assert_almost_equal(
trans.transform(50, 25, 0),
(3717892.6072086394, 4430811.87152035, 2679074.4628772778),
)
@pytest.mark.parametrize(
"pipeline_str",
[
"+proj=pipeline +ellps=GRS80 +step +proj=cart",
"+proj=pipeline +step +proj=unitconvert +xy_in=deg "
"+xy_out=rad +ellps=GRS80 +step +proj=cart",
],
)
def test_pipeline_itransform(pipeline_str):
trans = Transformer.from_pipeline(pipeline_str)
assert_almost_equal(
list(trans.itransform([(50, 25, 0)])),
[(3717892.6072086394, 4430811.87152035, 2679074.4628772778)],
)
@pytest.mark.parametrize(
"transformer",
[
partial(
Transformer.from_pipeline, "+proj=pipeline +ellps=GRS80 +step +proj=cart"
),
partial(Transformer.from_crs, 4326, 3857),
partial(Transformer.from_proj, 4326, 3857),
],
)
@patch.dict("os.environ", {"PROJ_NETWORK": "ON"}, clear=True)
def test_network__disable(transformer):
with proj_network_env():
pyproj.network.set_network_enabled(active=False)
trans = transformer()
assert trans.is_network_enabled is False
@pytest.mark.parametrize(
"transformer",
[
partial(
Transformer.from_pipeline, "+proj=pipeline +ellps=GRS80 +step +proj=cart"
),
partial(Transformer.from_crs, 4326, 3857),
partial(Transformer.from_proj, 4326, 3857),
],
)
@patch.dict("os.environ", {"PROJ_NETWORK": "OFF"}, clear=True)
def test_network__enable(transformer):
with proj_network_env():
pyproj.network.set_network_enabled(active=True)
trans = transformer()
assert trans.is_network_enabled is True
@pytest.mark.parametrize(
"transformer",
[
partial(
Transformer.from_pipeline, "+proj=pipeline +ellps=GRS80 +step +proj=cart"
),
partial(Transformer.from_crs, 4326, 3857),
partial(Transformer.from_proj, 4326, 3857),
],
)
def test_network__default(transformer):
with proj_network_env():
pyproj.network.set_network_enabled()
trans = transformer()
assert trans.is_network_enabled == (os.environ.get("PROJ_NETWORK") == "ON")
@patch.dict("os.environ", {"PROJ_NETWORK": "OFF"}, clear=True)
def test_transformer_group__network_enabled():
with proj_network_env():
pyproj.network.set_network_enabled(active=True)
trans_group = TransformerGroup(4326, 2964)
assert len(trans_group.unavailable_operations) == 0
assert len(trans_group.transformers) == 10
assert trans_group.best_available
for transformer in trans_group.transformers:
assert transformer.is_network_enabled is True
for operation in transformer.operations:
for grid in operation.grids:
assert grid.available
@pytest.mark.grid
@patch.dict("os.environ", {"PROJ_NETWORK": "ON"}, clear=True)
def test_transformer_group__network_disabled():
with proj_network_env():
pyproj.network.set_network_enabled(active=False)
trans_group = TransformerGroup(4326, 2964)
for transformer in trans_group.transformers:
assert transformer.is_network_enabled is False
if grids_available(
"us_noaa_alaska.tif",
"ca_nrc_ntv2_0.tif",
check_network=False,
check_all=True,
):
assert len(trans_group.unavailable_operations) == 0
assert len(trans_group.transformers) == 10
assert (
trans_group.transformers[0].description
== "Inverse of NAD27 to WGS 84 (85) + Alaska Albers"
)
assert trans_group.best_available
elif grids_available("us_noaa_alaska.tif", check_network=False):
assert len(trans_group.unavailable_operations) == 1
assert (
trans_group.transformers[0].description
== "Inverse of NAD27 to WGS 84 (85) + Alaska Albers"
)
assert len(trans_group.transformers) == 9
assert trans_group.best_available
elif grids_available("ca_nrc_ntv2_0.tif", check_network=False):
assert len(trans_group.unavailable_operations) == 1
assert (
trans_group.transformers[0].description
== "Inverse of NAD27 to WGS 84 (7) + Alaska Albers"
)
assert len(trans_group.transformers) == 9
assert not trans_group.best_available
else:
assert len(trans_group.unavailable_operations) == 2
assert (
trans_group.unavailable_operations[0].name
== "Inverse of NAD27 to WGS 84 (85) + Alaska Albers"
)
assert len(trans_group.transformers) == 8
assert not trans_group.best_available
def test_transform_pipeline_radians():
trans = Transformer.from_pipeline(
"+proj=pipeline +step +inv +proj=cart +ellps=WGS84 "
"+step +proj=unitconvert +xy_in=rad +xy_out=deg"
)
assert_almost_equal(
trans.transform(-2704026.010, -4253051.810, 3895878.820, radians=True),
(-2.137113493845668, 0.6613203738996222, -20.531156923621893),
)
assert_almost_equal(
trans.transform(
-2.137113493845668,
0.6613203738996222,
-20.531156923621893,
radians=True,
direction=TransformDirection.INVERSE,
),
(-2704026.010, -4253051.810, 3895878.820),
)
def test_itransform_pipeline_radians():
trans = Transformer.from_pipeline(
"+proj=pipeline +step +inv +proj=cart +ellps=WGS84 "
"+step +proj=unitconvert +xy_in=rad +xy_out=deg"
)
assert_almost_equal(
list(
trans.itransform([(-2704026.010, -4253051.810, 3895878.820)], radians=True)
),
[(-2.137113493845668, 0.6613203738996222, -20.531156923621893)],
)
assert_almost_equal(
list(
trans.itransform(
[(-2.137113493845668, 0.6613203738996222, -20.531156923621893)],
radians=True,
direction=TransformDirection.INVERSE,
)
),
[(-2704026.010, -4253051.810, 3895878.820)],
)
@pytest.mark.parametrize("x,y,z", permutations([10, [10], (10,)])) # 6 test cases
def test_transform_honours_input_types(x, y, z):
# 622
transformer = Transformer.from_proj(4896, 4896)
assert transformer.transform(xx=x, yy=y, zz=z) == (x, y, z)
@pytest.mark.grid
@pytest.mark.network
@patch("pyproj.transformer.get_user_data_dir")
def test_transformer_group__download_grids(get_user_data_dir_mock, tmp_path, capsys):
get_user_data_dir_mock.return_value = str(tmp_path)
with proj_network_env():
pyproj.network.set_network_enabled(active=False)
trans_group = TransformerGroup(4326, 2964)
trans_group.download_grids(verbose=True)
captured = capsys.readouterr()
get_user_data_dir_mock.assert_called_with(True)
paths = sorted(Path(path).name for path in glob(str(tmp_path.joinpath("*"))))
if grids_available(
"us_noaa_alaska.tif",
"ca_nrc_ntv2_0.tif",
check_network=False,
check_all=True,
):
assert paths == []
assert captured.out == ""
elif grids_available("us_noaa_alaska.tif", check_network=False):
assert paths == ["ca_nrc_ntv2_0.tif"]
assert (
captured.out == "Downloading: https://cdn.proj.org/ca_nrc_ntv2_0.tif\n"
)
elif grids_available("ca_nrc_ntv2_0.tif", check_network=False):
assert paths == ["us_noaa_alaska.tif"]
assert captured.out == (
"Downloading: https://cdn.proj.org/us_noaa_alaska.tif\n"
)
else:
assert paths == ["ca_nrc_ntv2_0.tif", "us_noaa_alaska.tif"]
assert captured.out == (
"Downloading: https://cdn.proj.org/us_noaa_alaska.tif\n"
"Downloading: https://cdn.proj.org/ca_nrc_ntv2_0.tif\n"
)
# make sure not downloaded again
with proj_env(), patch(
"pyproj.transformer._download_resource_file"
) as download_mock:
append_data_dir(str(tmp_path))
trans_group = TransformerGroup(4326, 2964)
trans_group.download_grids()
get_user_data_dir_mock.assert_called_with(True)
download_mock.assert_not_called()
@pytest.mark.grid
@patch("pyproj.transformer._download_resource_file")
@patch("pyproj.transformer.get_user_data_dir")
def test_transformer_group__download_grids__directory(
get_user_data_dir_mock, download_mock, tmp_path, capsys
):
with proj_network_env():
pyproj.network.set_network_enabled(active=False)
trans_group = TransformerGroup(4326, 2964)
trans_group.download_grids(directory=tmp_path)
get_user_data_dir_mock.assert_not_called()
captured = capsys.readouterr()
assert captured.out == ""
if grids_available(
"us_noaa_alaska.tif",
"ca_nrc_ntv2_0.tif",
check_network=False,
check_all=True,
):
download_mock.assert_not_called()
elif grids_available("us_noaa_alaska.tif", check_network=False):
download_mock.assert_called_with(
file_url="https://cdn.proj.org/ca_nrc_ntv2_0.tif",
short_name="ca_nrc_ntv2_0.tif",
directory=tmp_path,
verbose=False,
)
elif grids_available("ca_nrc_ntv2_0.tif", check_network=False):
download_mock.assert_called_with(
file_url="https://cdn.proj.org/us_noaa_alaska.tif",
short_name="us_noaa_alaska.tif",
directory=tmp_path,
verbose=False,
)
else:
download_mock.assert_has_calls(
[
call(
file_url="https://cdn.proj.org/us_noaa_alaska.tif",
short_name="us_noaa_alaska.tif",
directory=tmp_path,
verbose=False,
),
call(
file_url="https://cdn.proj.org/ca_nrc_ntv2_0.tif",
short_name="ca_nrc_ntv2_0.tif",
directory=tmp_path,
verbose=False,
),
],
any_order=True,
)
@pytest.mark.skipif(
pyproj._datadir._USE_GLOBAL_CONTEXT, reason="Global Context not Threadsafe."
)
def test_transformer_multithread__pipeline():
# https://github.com/pyproj4/pyproj/issues/782
trans = Transformer.from_pipeline(
"+proj=pipeline +step +inv +proj=cart +ellps=WGS84 "
"+step +proj=unitconvert +xy_in=rad +xy_out=deg"
)
def transform(num):
return trans.transform(-2704026.010, -4253051.810, 3895878.820)
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
for result in executor.map(transform, range(10)):
pass
@pytest.mark.skipif(
pyproj._datadir._USE_GLOBAL_CONTEXT, reason="Global Context not Threadsafe."
)
def test_transformer_multithread__crs():
# https://github.com/pyproj4/pyproj/issues/782
trans = Transformer.from_crs(4326, 3857)
def transform(num):
return trans.transform(1, 2)
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
for result in executor.map(transform, range(10)):
pass
def test_transformer_accuracy_filter():
with pytest.raises(ProjError):
Transformer.from_crs("EPSG:4326", "EPSG:4258", accuracy=0.05)
def test_transformer_allow_ballpark_filter():
with pytest.raises(ProjError):
Transformer.from_crs(
"EPSG:4326", "EPSG:4258", authority="PROJ", allow_ballpark=False
)
def test_transformer_authority_filter():
transformer = Transformer.from_crs("EPSG:4326", "EPSG:4258", authority="PROJ")
assert transformer.description == "Ballpark geographic offset from WGS 84 to ETRS89"
@pytest.mark.parametrize(
"input_string",
[
"EPSG:1671",
"RGF93 v1 to WGS 84 (1)",
"urn:ogc:def:coordinateOperation:EPSG::1671",
],
)
def test_transformer_from_pipeline__input_types(input_string):
assert (
Transformer.from_pipeline(input_string).description == "RGF93 v1 to WGS 84 (1)"
)
@pytest.mark.parametrize(
"method_name",
[
"to_wkt",
"to_json",
],
)
def test_transformer_from_pipeline__wkt_json(method_name):
assert (
Transformer.from_pipeline(
getattr(
Transformer.from_pipeline("urn:ogc:def:coordinateOperation:EPSG::1671"),
method_name,
)()
).description
== "RGF93 v1 to WGS 84 (1)"
)
@pytest.mark.parametrize(
"density,expected",
[
(0, (-1684649.41338, -350356.81377, 1684649.41338, 2234551.18559)),
(100, (-1684649.41338, -555777.79210, 1684649.41338, 2234551.18559)),
],
)
def test_transform_bounds_densify(density, expected):
transformer = Transformer.from_crs(
"EPSG:4326",
"+proj=laea +lat_0=45 +lon_0=-100 +x_0=0 +y_0=0 "
"+a=6370997 +b=6370997 +units=m +no_defs",
)
assert numpy.allclose(
transformer.transform_bounds(40, -120, 64, -80, densify_pts=density),
expected,
)
@pytest.mark.parametrize(
"density,expected",
[
(0, (-1684649.41338, -350356.81377, 1684649.41338, 2234551.18559)),
(100, (-1684649.41338, -555777.79210, 1684649.41338, 2234551.18559)),
],
)
@pytest.mark.parametrize(
"input_bounds, radians",
[
((-120, 40, -80, 64), False),
(
(
numpy.radians(-120),
numpy.radians(40),
numpy.radians(-80),
numpy.radians(64),
),
True,
),
],
)
def test_transform_bounds_densify__xy(density, expected, input_bounds, radians):
transformer = Transformer.from_crs(
"EPSG:4326",
"+proj=laea +lat_0=45 +lon_0=-100 +x_0=0 +y_0=0 "
"+a=6370997 +b=6370997 +units=m +no_defs",
always_xy=True,
)
assert numpy.allclose(
transformer.transform_bounds(
*input_bounds, densify_pts=density, radians=radians
),
expected,
)
def test_transform_bounds_densify_out_of_bounds():
transformer = Transformer.from_crs(
"EPSG:4326",
"+proj=laea +lat_0=45 +lon_0=-100 +x_0=0 +y_0=0 "
"+a=6370997 +b=6370997 +units=m +no_defs",
always_xy=True,
)
with pytest.raises(ProjError):
transformer.transform_bounds(-120, 40, -80, 64, densify_pts=-1)
def test_transform_bounds_densify_out_of_bounds__geographic_output():
transformer = Transformer.from_crs(
"+proj=laea +lat_0=45 +lon_0=-100 +x_0=0 +y_0=0 "
"+a=6370997 +b=6370997 +units=m +no_defs",
"EPSG:4326",
always_xy=True,
)
with pytest.raises(ProjError):
transformer.transform_bounds(-120, 40, -80, 64, densify_pts=1)
def test_transform_bounds_radians_output():
transformer = Transformer.from_crs(
"EPSG:4326",
"+proj=geocent +ellps=WGS84 +datum=WGS84",
always_xy=True,
)
assert_almost_equal(
transformer.transform_bounds(
-2704026.010,
-4253051.810,
-2704025.010,
-4253050.810,
radians=True,
direction="INVERSE",
),
(-2.1371136, 0.0, -2.1371133, 0.0),
)
def test_transform_bounds__antimeridian():
crs = CRS("EPSG:3851")
transformer = Transformer.from_crs(crs.geodetic_crs, crs)
minx, miny, maxx, maxy = crs.area_of_use.bounds
transformed_bounds = transformer.transform_bounds(miny, minx, maxy, maxx)
assert_almost_equal(
transformed_bounds,
(5228058.6143420935, 1722483.900174921, 8692574.544944234, 4624385.494808555),
)
assert_almost_equal(
transformer.transform_bounds(
*transformed_bounds,
direction="INVERSE",
),
(-56.7471249, 153.2799922, -24.6148194, -162.1813873),
)
def test_transform_bounds__antimeridian__xy():
crs = CRS("EPSG:3851")
transformer = Transformer.from_crs(
crs.geodetic_crs,
crs,
always_xy=True,
)
transformed_bounds = transformer.transform_bounds(*crs.area_of_use.bounds)
assert_almost_equal(
transformed_bounds,
(1722483.900174921, 5228058.6143420935, 4624385.494808555, 8692574.544944234),
)
assert_almost_equal(
transformer.transform_bounds(*transformed_bounds, direction="INVERSE"),
(153.2799922, -56.7471249, -162.1813873, -24.6148194),
)
def test_transform_bounds__beyond_global_bounds():
transformer = Transformer.from_crs(
"EPSG:6933",
"EPSG:4326",
always_xy=True,
)
assert_almost_equal(
transformer.transform_bounds(
-17367531.3203125, -7314541.19921875, 17367531.3203125, 7314541.19921875
),
(-180, -85.0445994113099, 180, 85.0445994113099),
)
@pytest.mark.parametrize(
"input_crs,input_bounds,expected_bounds",
[
(
"ESRI:102036",
(-180.0, -90.0, 180.0, 1.3 if PROJ_GTE_92 else 0),
(0, -116576599 if PROJ_GTE_92 else -89178008, 0, 0),
),
("ESRI:54026", (-180.0, -90.0, 180.0, 90.0), (0, -179545824, 0, 179545824)),
],
)
def test_transform_bounds__ignore_inf(input_crs, input_bounds, expected_bounds):
crs = CRS(input_crs)
transformer = Transformer.from_crs(crs.geodetic_crs, crs, always_xy=True)
assert_almost_equal(
transformer.transform_bounds(*input_bounds),
expected_bounds,
decimal=0,
)
def test_transform_bounds__ignore_inf_geographic():
crs_wkt = (
'PROJCS["Interrupted_Goode_Homolosine",'
'GEOGCS["GCS_unnamed ellipse",DATUM["D_unknown",'
'SPHEROID["Unknown",6378137,298.257223563]],'
'PRIMEM["Greenwich",0],UNIT["Degree",0.0174532925199433]],'
'PROJECTION["Interrupted_Goode_Homolosine"],'
'UNIT["metre",1,AUTHORITY["EPSG","9001"]],'
'AXIS["Easting",EAST],AXIS["Northing",NORTH]]'
)
transformer = Transformer.from_crs(crs_wkt, "EPSG:4326", always_xy=True)
assert_almost_equal(
transformer.transform_bounds(
left=-15028000.0, bottom=7515000.0, right=-14975000.0, top=7556000.0
),
(-179.2133, 70.9345, -177.9054, 71.4364),
decimal=0,
)
def test_transform_bounds__noop_geographic():
crs = CRS("Pulkovo 1942")
transformer = Transformer.from_crs(crs.geodetic_crs, crs, always_xy=True)
assert_almost_equal(
transformer.transform_bounds(*crs.area_of_use.bounds),
crs.area_of_use.bounds,
)
def test_transform_bounds__north_pole():
crs = CRS("EPSG:32661")
transformer = Transformer.from_crs(crs, "EPSG:4326")
minx, miny, maxx, maxy = crs.area_of_use.bounds
bounds = transformer.transform_bounds(miny, minx, maxy, maxx, direction="INVERSE")
assert_almost_equal(
bounds,
(
-1405880.72,
-1371213.76,
5405880.72,
5371213.76,
),
decimal=0,
)
assert_almost_equal(
transformer.transform_bounds(*bounds),
(48.656, -180.0, 90.0, 180.0),
decimal=0,
)
def test_transform_bounds__north_pole__xy():
crs = CRS("EPSG:32661")
transformer = Transformer.from_crs(crs, "EPSG:4326", always_xy=True)
bounds = transformer.transform_bounds(*crs.area_of_use.bounds, direction="INVERSE")
assert_almost_equal(
bounds,
(-1371213.76, -1405880.72, 5371213.76, 5405880.72),
decimal=0,
)
assert_almost_equal(
transformer.transform_bounds(*bounds),
(-180.0, 48.656, 180.0, 90.0),
decimal=0,
)
def test_transform_bounds__south_pole():
crs = CRS("EPSG:32761")
transformer = Transformer.from_crs(crs, "EPSG:4326")
minx, miny, maxx, maxy = crs.area_of_use.bounds
bounds = transformer.transform_bounds(miny, minx, maxy, maxx, direction="INVERSE")
assert_almost_equal(
bounds,
(
-1405880.72,
-1371213.76,
5405880.72,
5371213.76,
),
decimal=0,
)
assert_almost_equal(
transformer.transform_bounds(*bounds),
(-90, -180.0, -48.656, 180.0),
decimal=0,
)
def test_transform_bounds__south_pole__xy():
crs = CRS("EPSG:32761")
transformer = Transformer.from_crs(crs, "EPSG:4326", always_xy=True)
bounds = transformer.transform_bounds(*crs.area_of_use.bounds, direction="INVERSE")
assert_almost_equal(
bounds,
(-1371213.76, -1405880.72, 5371213.76, 5405880.72),
decimal=0,
)
assert_almost_equal(
transformer.transform_bounds(*bounds),
(-180.0, -90.0, 180.0, -48.656),
decimal=0,
)
@pytest.mark.parametrize("inplace", [True, False])
def test_transform__fortran_order(inplace):
lons, lats = numpy.arange(-180, 180, 20), numpy.arange(-90, 90, 10)
lats, lons = numpy.meshgrid(lats, lons)
f_lons, f_lats = lons.copy(order="F"), lats.copy(order="F")
transformer = Transformer.from_crs(
"EPSG:4326",
"EPSG:6933",
always_xy=True,
)
xxx, yyy = transformer.transform(lons, lats)
f_xxx, f_yyy = transformer.transform(f_lons, f_lats, inplace=inplace)
assert f_lons.flags.f_contiguous
assert f_lats.flags.f_contiguous
assert not f_xxx.flags.f_contiguous
assert f_xxx.flags.c_contiguous
assert not f_yyy.flags.f_contiguous
assert f_yyy.flags.c_contiguous
assert_array_equal(xxx, f_xxx)
assert_array_equal(yyy, f_yyy)
def test_4d_transform__inplace__array():
transformer = Transformer.from_crs(7789, 8401)
xarr = array("d", [3496737.2679])
yarr = array("d", [743254.4507])
zarr = array("d", [5264462.9620])
tarr = array("d", [2019.0])
t_xarr, t_yarr, t_zarr, t_tarr = transformer.transform(
xx=xarr, yy=yarr, zz=zarr, tt=tarr, inplace=True
)
assert xarr is t_xarr
assert_almost_equal(xarr[0], 3496737.757717311)
assert yarr is t_yarr
assert_almost_equal(yarr[0], 743253.9940103051)
assert zarr is t_zarr
assert_almost_equal(zarr[0], 5264462.701132784)
assert tarr is t_tarr
assert_almost_equal(tarr[0], 2019.0)
def test_4d_transform__inplace__array__int():
transformer = Transformer.from_crs(7789, 8401)
xarr = array("i", [3496737])
yarr = array("i", [743254])
zarr = array("i", [5264462])
tarr = array("i", [2019])
t_xarr, t_yarr, t_zarr, t_tarr = transformer.transform(
xx=xarr, yy=yarr, zz=zarr, tt=tarr, inplace=True
)
assert xarr is not t_xarr
assert xarr[0] == 3496737
assert yarr is not t_yarr
assert yarr[0] == 743254
assert zarr is not t_zarr
assert zarr[0] == 5264462
assert tarr is not t_tarr
assert tarr[0] == 2019
def test_4d_transform__inplace__numpy():
transformer = Transformer.from_crs(7789, 8401)
xarr = numpy.array([3496737.2679], dtype=numpy.float64)
yarr = numpy.array([743254.4507], dtype=numpy.float64)
zarr = numpy.array([5264462.9620], dtype=numpy.float64)
tarr = numpy.array([2019.0], dtype=numpy.float64)
t_xarr, t_yarr, t_zarr, t_tarr = transformer.transform(
xx=xarr, yy=yarr, zz=zarr, tt=tarr, inplace=True
)
assert xarr is t_xarr
assert_almost_equal(xarr[0], 3496737.757717311)
assert yarr is t_yarr
assert_almost_equal(yarr[0], 743253.9940103051)
assert zarr is t_zarr
assert_almost_equal(zarr[0], 5264462.701132784)
assert tarr is t_tarr
assert_almost_equal(tarr[0], 2019.0)
def test_4d_transform__inplace__numpy__int():
transformer = Transformer.from_crs(7789, 8401)
xarr = numpy.array([3496737], dtype=numpy.int32)
yarr = numpy.array([743254], dtype=numpy.int32)
zarr = numpy.array([5264462], dtype=numpy.int32)
tarr = numpy.array([2019], dtype=numpy.int32)
t_xarr, t_yarr, t_zarr, t_tarr = transformer.transform(
xx=xarr, yy=yarr, zz=zarr, tt=tarr, inplace=True
)
assert xarr is not t_xarr
assert xarr[0] == 3496737
assert yarr is not t_yarr
assert yarr[0] == 743254
assert zarr is not t_zarr
assert zarr[0] == 5264462
assert tarr is not t_tarr
assert tarr[0] == 2019
def test_transformer_source_target_crs():
transformer = Transformer.from_crs("EPSG:4326", "EPSG:4258")
assert transformer.source_crs == "EPSG:4326"
assert transformer.target_crs == "EPSG:4258"
def test_transformer_source_target_crs__none():
transformer = Transformer.from_pipeline("+init=ITRF2008:ITRF2000")
assert transformer.source_crs is None
assert transformer.target_crs is None
def test_pickle_transformer_from_pipeline():
transformer = Transformer.from_pipeline("+init=ITRF2008:ITRF2000")
assert transformer == pickle.loads(pickle.dumps(transformer))
def test_pickle_transformer_from_crs():
transformer = Transformer.from_crs(
"EPSG:4326",
"EPSG:2964",
always_xy=True,
area_of_interest=AreaOfInterest(-136.46, 49.0, -60.72, 83.17),
)
assert transformer == pickle.loads(pickle.dumps(transformer))
def test_unpickle_transformer_from_crs_v1_3():
pickled_transformer = (
b"\x80\x04\x95p\x01\x00\x00\x00\x00\x00\x00\x8c\x12"
b"pyproj.transformer\x94\x8c\x0bTransformer\x94\x93\x94)"
b"\x81\x94}\x94\x8c\x12_transformer_maker\x94h\x00\x8c\x12"
b"TransformerFromCRS\x94\x93\x94)\x81\x94}\x94(\x8c\x08"
b"crs_from\x94C\tEPSG:4326\x94\x8c\x06crs_to\x94C\tEPSG:2964"
b"\x94\x8c\talways_xy\x94\x88\x8c\x10area_of_interest\x94\x8c\n"
b"pyproj.aoi\x94\x8c\x0eAreaOfInterest\x94\x93\x94)\x81\x94}\x94"
b"(\x8c\x0fwest_lon_degree\x94G\xc0a\x0e\xb8Q\xeb\x85\x1f\x8c\x10"
b"south_lat_degree\x94G@H\x80\x00\x00\x00\x00\x00\x8c\x0f"
b"east_lon_degree\x94G\xc0N\\(\xf5\xc2\x8f\\\x8c\x10"
b"north_lat_degree\x94G@T\xca\xe1G\xae\x14"
b"{ub\x8c\tauthority\x94N\x8c\x08accuracy\x94N\x8c\x0eallow_ballpark\x94Nubsb."
)
transformer = Transformer.from_crs(
"EPSG:4326",
"EPSG:2964",
always_xy=True,
area_of_interest=AreaOfInterest(-136.46, 49.0, -60.72, 83.17),
)
assert transformer == pickle.loads(pickled_transformer)
def test_transformer_group_accuracy_filter():
group = TransformerGroup("EPSG:4326", "EPSG:4258", accuracy=0.05)
assert not group.transformers
assert not group.unavailable_operations
def test_transformer_group_allow_ballpark_filter():
group = TransformerGroup(
"EPSG:4326", "EPSG:4258", authority="PROJ", allow_ballpark=False
)
assert not group.transformers
assert not group.unavailable_operations
def test_transformer_group_allow_superseded_filter():
default_group = TransformerGroup(4203, 4326)
superseded_group = TransformerGroup(4203, 4326, allow_superseded=True)
assert len(superseded_group.transformers) > len(default_group.transformers)
def test_transformer_group_authority_filter():
group = TransformerGroup("EPSG:4326", "EPSG:4258", authority="PROJ")
assert len(group.transformers) == 1
assert not group.unavailable_operations
assert (
group.transformers[0].description
== "Ballpark geographic offset from WGS 84 to ETRS89"
)
def test_transformer_force_over():
transformer = Transformer.from_crs("EPSG:4326", "EPSG:3857", force_over=True)
# Test a point along the equator.
# The same point, but in two different representations.
xxx, yyy = transformer.transform(0, 140)
xxx_over, yyy_over = transformer.transform(0, -220)
# Web Mercator x's between 0 and 180 longitude come out positive.
# But when forcing the over flag, the -220 calculation makes it flip.
assert xxx > 0
assert xxx_over < 0
# check it works in both directions
xxx_inverse, yyy_inverse = transformer.transform(
xxx, yyy, direction=TransformDirection.INVERSE
)
xxx_over_inverse, yyy_over_inverse = transformer.transform(
xxx_over, yyy_over, direction=TransformDirection.INVERSE
)
assert_almost_equal(xxx_inverse, 0)
assert_almost_equal(xxx_over_inverse, 0)
assert_almost_equal(yyy_inverse, 140)
assert_almost_equal(yyy_over_inverse, -220)
def test_transformer__get_last_used_operation():
transformer = Transformer.from_crs("EPSG:4326", "EPSG:3857")
if PROJ_GTE_91:
with pytest.raises(
ProjError,
match=(
r"Last used operation not found\. "
r"This is likely due to not initiating a transform\."
),
):
transformer.get_last_used_operation()
xxx, yyy = transformer.transform(1, 2)
operation = transformer.get_last_used_operation()
assert isinstance(operation, Transformer)
assert xxx, yyy == operation.transform(1, 2)
else:
with pytest.raises(
NotImplementedError,
match=r"PROJ 9\.1\+ required to get last used operation\.",
):
transformer.get_last_used_operation()
pyproj-3.6.1/test/test_utils.py 0000664 0000000 0000000 00000003745 14502715416 0016612 0 ustar 00root root 0000000 0000000 from array import array
import numpy
import pytest
from pyproj.utils import DataType, _copytobuffer, _copytobuffer_return_scalar
@pytest.mark.parametrize("in_data", [numpy.array(1), 1])
def test__copytobuffer_return_scalar(in_data):
assert _copytobuffer_return_scalar(in_data) == (array("d", [1]), DataType.FLOAT)
def test__copytobuffer_return_scalar__invalid():
with pytest.raises(TypeError):
_copytobuffer_return_scalar("invalid")
@pytest.mark.parametrize(
"in_data, data_type",
[
(numpy.array(1), DataType.FLOAT),
(1, DataType.FLOAT),
([1], DataType.LIST),
((1,), DataType.TUPLE),
],
)
def test__copytobuffer(in_data, data_type):
assert _copytobuffer(in_data) == (array("d", [1]), data_type)
def test__copytobuffer__xarray_scalar():
xarray = pytest.importorskip("xarray")
assert _copytobuffer(xarray.DataArray(numpy.array(1))) == (
array("d", [1]),
DataType.FLOAT,
)
@pytest.mark.parametrize("arr_type", ["numpy", "xarray", "pandas"])
def test__copytobuffer__array(arr_type):
in_arr = numpy.array([1])
if arr_type == "xarray":
xarray = pytest.importorskip("xarray")
in_arr = xarray.DataArray(in_arr)
elif arr_type == "pandas":
pandas = pytest.importorskip("pandas")
in_arr = pandas.Series(in_arr)
assert _copytobuffer(in_arr) == (
in_arr.astype("d").__array__(),
DataType.ARRAY,
)
def test__copytobuffer__numpy_masked_array():
in_arr = numpy.ma.array([1])
out_arr, dtype = _copytobuffer(in_arr)
assert isinstance(out_arr, numpy.ma.MaskedArray)
def test__copytobuffer__fortran_order():
data = numpy.ones((2, 4), dtype=numpy.float64, order="F")
converted_data, dtype = _copytobuffer(data)
assert data.flags.f_contiguous
assert not converted_data.flags.f_contiguous
assert converted_data.flags.c_contiguous
def test__copytobuffer__invalid():
with pytest.raises(TypeError):
_copytobuffer("invalid")