In [1]:
import cartopy.crs as ccrs
Documentation for supported projections is at:
https://scitools.org.uk/cartopy/docs/latest/crs/projections.html
In [2]:
help(ccrs)
Help on module cartopy.crs in cartopy:
NAME
cartopy.crs
DESCRIPTION
The crs module defines Coordinate Reference Systems and the transformations
between them.
CLASSES
cartopy._crs.CRS(builtins.object)
Projection
AlbersEqualArea
AzimuthalEquidistant
Gnomonic
InterruptedGoodeHomolosine
LambertAzimuthalEqualArea
LambertConformal
Mercator
Orthographic
Sinusoidal
Stereographic
NorthPolarStereo
SouthPolarStereo
TransverseMercator
OSGB
OSNI
UTM
EuroPP
RotatedGeodetic
_CylindricalProjection(_RectangularProjection)
PlateCarree
RotatedPole
_RectangularProjection(Projection)
LambertCylindrical
Miller
_Satellite(Projection)
Geostationary
NearsidePerspective
_WarpedRectangularProjection(Projection)
Mollweide
Robinson
class AlbersEqualArea(Projection)
| An Albers Equal Area projection
|
| This projection is conic and equal-area, and is commonly used for maps of
| the conterminous United States.
|
| Method resolution order:
| AlbersEqualArea
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, central_latitude=0.0, false_easting=0.0, false_northing=0.0, standard_parallels=(20.0, 50.0), globe=None)
| Parameters
| ----------
| central_longitude: optional
| The central longitude. Defaults to 0.
| central_latitude: optional
| The central latitude. Defaults to 0.
| false_easting: optional
| X offset from planar origin in metres. Defaults to 0.
| false_northing: optional
| Y offset from planar origin in metres. Defaults to 0.
| standard_parallels: optional
| The one or two latitudes of correct scale. Defaults to (20, 50).
| globe: optional
| A :class:`cartopy.crs.Globe`. If omitted, a default globe is
| created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class AzimuthalEquidistant(Projection)
| An Azimuthal Equidistant projection
|
| This projection provides accurate angles about and distances through the
| central position. Other angles, distances, or areas may be distorted.
|
| Method resolution order:
| AzimuthalEquidistant
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, central_latitude=0.0, false_easting=0.0, false_northing=0.0, globe=None)
| Parameters
| ----------
| central_longitude: optional
| The true longitude of the central meridian in degrees.
| Defaults to 0.
| central_latitude: optional
| The true latitude of the planar origin in degrees.
| Defaults to 0.
| false_easting: optional
| X offset from the planar origin in metres. Defaults to 0.
| false_northing: optional
| Y offset from the planar origin in metres. Defaults to 0.
| globe: optional
| An instance of :class:`cartopy.crs.Globe`. If omitted, a default
| globe is created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class EuroPP(UTM)
| UTM Zone 32 projection for EuroPP domain.
|
| Ellipsoid is International 1924, Datum is ED50.
|
| Method resolution order:
| EuroPP
| UTM
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self)
| Parameters
| ----------
| zone
| The numeric zone of the UTM required.
| southern_hemisphere: optional
| Set to True if the zone is in the southern hemisphere. Defaults to
| False.
| globe: optional
| An instance of :class:`cartopy.crs.Globe`. If omitted, a default
| globe is created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from UTM:
|
| boundary
|
| threshold
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Geostationary(_Satellite)
| Perspective view looking directly down from above a point on the equator.
|
| Method resolution order:
| Geostationary
| _Satellite
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, satellite_height=35785831, false_easting=0, false_northing=0, globe=None, sweep_axis='y')
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _Satellite:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Gnomonic(Projection)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| Gnomonic
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_latitude=0.0, central_longitude=0.0, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class InterruptedGoodeHomolosine(Projection)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| InterruptedGoodeHomolosine
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class LambertAzimuthalEqualArea(Projection)
| A Lambert Azimuthal Equal-Area projection.
|
| Method resolution order:
| LambertAzimuthalEqualArea
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, central_latitude=0.0, false_easting=0.0, false_northing=0.0, globe=None)
| Parameters
| ----------
| central_longitude: optional
| The central longitude. Defaults to 0.
| central_latitude: optional
| The central latitude. Defaults to 0.
| false_easting: optional
| X offset from planar origin in metres. Defaults to 0.
| false_northing: optional
| Y offset from planar origin in metres. Defaults to 0.
| globe: optional
| A :class:`cartopy.crs.Globe`. If omitted, a default globe is
| created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class LambertConformal(Projection)
| A Lambert Conformal conic projection.
|
| Method resolution order:
| LambertConformal
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __hash__(self)
| Hash the CRS based on its proj4_init string.
|
| __init__(self, central_longitude=-96.0, central_latitude=39.0, false_easting=0.0, false_northing=0.0, secant_latitudes=None, standard_parallels=None, globe=None, cutoff=-30)
| Parameters
| ----------
| central_longitude: optional
| The central longitude. Defaults to -96.
| central_latitude: optional
| The central latitude. Defaults to 39.
| false_easting: optional
| X offset from planar origin in metres. Defaults to 0.
| false_northing: optional
| Y offset from planar origin in metres. Defaults to 0.
| secant_latitudes: optional
| Secant latitudes. This keyword is deprecated in v0.12 and directly
| replaced by ``standard parallels``. Defaults to None.
| standard_parallels: optional
| Standard parallel latitude(s). Defaults to (33, 45).
| globe: optional
| A :class:`cartopy.crs.Globe`. If omitted, a default globe is
| created.
| cutoff: optional
| Latitude of map cutoff.
| The map extends to infinity opposite the central pole
| so we must cut off the map drawing before then.
| A value of 0 will draw half the globe. Defaults to -30.
|
| __ne__(self, other)
| Return self!=value.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class LambertCylindrical(_RectangularProjection)
| The abstract superclass of projections with a rectangular domain which
| is symmetric about the origin.
|
| Method resolution order:
| LambertCylindrical
| _RectangularProjection
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| threshold
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RectangularProjection:
|
| boundary
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Mercator(Projection)
| A Mercator projection.
|
| Method resolution order:
| Mercator
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __hash__(self)
| Hash the CRS based on its proj4_init string.
|
| __init__(self, central_longitude=0.0, min_latitude=-80.0, max_latitude=84.0, globe=None, latitude_true_scale=0.0)
| Parameters
| ----------
| central_longitude: optional
| The central longitude. Defaults to 0.
| min_latitude: optional
| The maximum southerly extent of the projection. Defaults
| to -80 degrees.
| max_latitude: optional
| The maximum northerly extent of the projection. Defaults
| to 84 degrees.
| globe: A :class:`cartopy.crs.Globe`, optional
| If omitted, a default globe is created.
| latitude_true_scale: optional
| The latitude where the scale is 1. Defaults to 0 degrees.
|
| __ne__(self, other)
| Return self!=value.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| GOOGLE = <cartopy.crs.Mercator object>
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Miller(_RectangularProjection)
| The abstract superclass of projections with a rectangular domain which
| is symmetric about the origin.
|
| Method resolution order:
| Miller
| _RectangularProjection
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| threshold
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RectangularProjection:
|
| boundary
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Mollweide(_WarpedRectangularProjection)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| Mollweide
| _WarpedRectangularProjection
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| threshold
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _WarpedRectangularProjection:
|
| boundary
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class NearsidePerspective(_Satellite)
| Perspective view looking directly down from above a point on the globe.
|
| Method resolution order:
| NearsidePerspective
| _Satellite
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, central_latitude=0.0, satellite_height=35785831, false_easting=0, false_northing=0, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _Satellite:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class NorthPolarStereo(Stereographic)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| NorthPolarStereo
| Stereographic
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, true_scale_latitude=None, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Stereographic:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class OSGB(TransverseMercator)
| A Transverse Mercator projection.
|
| Method resolution order:
| OSGB
| TransverseMercator
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self)
| Parameters
| ----------
| central_longitude: optional
| The true longitude of the central meridian in degrees.
| Defaults to 0.
| central_latitude: optional
| The true latitude of the planar origin in degrees. Defaults to 0.
| false_easting: optional
| X offset from the planar origin in metres. Defaults to 0.
| false_northing: optional
| Y offset from the planar origin in metres. Defaults to 0.
| scale_factor: optional
| Scale factor at the central meridian. Defaults to 1.
| globe: optional
| An instance of :class:`cartopy.crs.Globe`. If omitted, a default
| globe is created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransverseMercator:
|
| threshold
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class OSNI(TransverseMercator)
| A Transverse Mercator projection.
|
| Method resolution order:
| OSNI
| TransverseMercator
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self)
| Parameters
| ----------
| central_longitude: optional
| The true longitude of the central meridian in degrees.
| Defaults to 0.
| central_latitude: optional
| The true latitude of the planar origin in degrees. Defaults to 0.
| false_easting: optional
| X offset from the planar origin in metres. Defaults to 0.
| false_northing: optional
| Y offset from the planar origin in metres. Defaults to 0.
| scale_factor: optional
| Scale factor at the central meridian. Defaults to 1.
| globe: optional
| An instance of :class:`cartopy.crs.Globe`. If omitted, a default
| globe is created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from TransverseMercator:
|
| threshold
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Orthographic(Projection)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| Orthographic
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, central_latitude=0.0, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class PlateCarree(_CylindricalProjection)
| The abstract class which denotes cylindrical projections where we
| want to allow x values to wrap around.
|
| Method resolution order:
| PlateCarree
| _CylindricalProjection
| _RectangularProjection
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| threshold
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RectangularProjection:
|
| boundary
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Projection(cartopy._crs.CRS)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| boundary
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset({'boundary', 'threshold', 'x_limits', ...
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __init__(...)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Robinson(_WarpedRectangularProjection)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| Robinson
| _WarpedRectangularProjection
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| transform_point(self, x, y, src_crs)
| Capture and handle any input NaNs, else invoke parent function,
| :meth:`_WarpedRectangularProjection.transform_point`.
|
| Needed because input NaNs can trigger a fatal error in the underlying
| implementation of the Robinson projection.
|
| Note
| ----
| Although the original can in fact translate (nan, lat) into
| (nan, y-value), this patched version doesn't support that.
|
| transform_points(self, src_crs, x, y, z=None)
| Capture and handle NaNs in input points -- else as parent function,
| :meth:`_WarpedRectangularProjection.transform_points`.
|
| Needed because input NaNs can trigger a fatal error in the underlying
| implementation of the Robinson projection.
|
| Note
| ----
| Although the original can in fact translate (nan, lat) into
| (nan, y-value), this patched version doesn't support that.
| Instead, we invalidate any of the points that contain a NaN.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| threshold
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _WarpedRectangularProjection:
|
| boundary
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class RotatedGeodetic(cartopy._crs.CRS)
| Define a rotated latitude/longitude coordinate system with spherical
| topology and geographical distance.
|
| Coordinates are measured in degrees.
|
| The class uses proj4 to perform an ob_tran operation, using the
| pole_longitude to set a lon_0 then performing two rotations based on
| pole_latitude and central_rotated_longitude.
| This is equivalent to setting the new pole to a location defined by
| the pole_latitude and pole_longitude values in the GeogCRS defined by
| globe, then rotating this new CRS about it's pole using the
| central_rotated_longitude value.
|
| Method resolution order:
| RotatedGeodetic
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, pole_longitude, pole_latitude, central_rotated_longitude=0.0, globe=None)
| Parameters
| ----------
| pole_longitude
| Pole longitude position, in unrotated degrees.
| pole_latitude
| Pole latitude position, in unrotated degrees.
| central_rotated_longitude: optional
| Longitude rotation about the new pole, in degrees. Defaults to 0.
| globe: optional
| A :class:`cartopy.crs.Globe`. Defaults to a "WGS84" datum.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class RotatedPole(_CylindricalProjection)
| A rotated latitude/longitude projected coordinate system
| with cylindrical topology and projected distance.
|
| Coordinates are measured in projection metres.
|
| The class uses proj4 to perform an ob_tran operation, using the
| pole_longitude to set a lon_0 then performing two rotations based on
| pole_latitude and central_rotated_longitude.
| This is equivalent to setting the new pole to a location defined by
| the pole_latitude and pole_longitude values in the GeogCRS defined by
| globe, then rotating this new CRS about it's pole using the
| central_rotated_longitude value.
|
| Method resolution order:
| RotatedPole
| _CylindricalProjection
| _RectangularProjection
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, pole_longitude=0.0, pole_latitude=90.0, central_rotated_longitude=0.0, globe=None)
| Parameters
| ----------
| pole_longitude: optional
| Pole longitude position, in unrotated degrees. Defaults to 0.
| pole_latitude: optional
| Pole latitude position, in unrotated degrees. Defaults to 0.
| central_rotated_longitude: optional
| Longitude rotation about the new pole, in degrees. Defaults to 0.
| globe: optional
| An optional :class:`cartopy.crs.Globe`. Defaults to a "WGS84"
| datum.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| threshold
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from _RectangularProjection:
|
| boundary
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Sinusoidal(Projection)
| A Sinusoidal projection.
|
| This projection is equal-area.
|
| Method resolution order:
| Sinusoidal
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, false_easting=0.0, false_northing=0.0, globe=None)
| Parameters
| ----------
| central_longitude: optional
| The central longitude. Defaults to 0.
| false_easting: optional
| X offset from planar origin in metres. Defaults to 0.
| false_northing: optional
| Y offset from planar origin in metres. Defaults to 0.
| globe: optional
| A :class:`cartopy.crs.Globe`. If omitted, a default globe is
| created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| MODIS = <cartopy.crs.Sinusoidal object>
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class SouthPolarStereo(Stereographic)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| SouthPolarStereo
| Stereographic
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, true_scale_latitude=None, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Stereographic:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class Stereographic(Projection)
| Define a projected coordinate system with flat topology and Euclidean
| distance.
|
| Method resolution order:
| Stereographic
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_latitude=0.0, central_longitude=0.0, false_easting=0.0, false_northing=0.0, true_scale_latitude=None, scale_factor=None, globe=None)
| Parameters
| ----------
| proj4_params: iterable of key-value pairs
| The proj4 parameters required to define the
| desired CRS. The parameters should not describe
| the desired elliptic model, instead create an
| appropriate Globe instance. The ``proj4_params``
| parameters will override any parameters that the
| Globe defines.
| globe: :class:`~cartopy.crs.Globe` instance, optional
| If omitted, the default Globe instance will be created.
| See :class:`~cartopy.crs.Globe` for details.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class TransverseMercator(Projection)
| A Transverse Mercator projection.
|
| Method resolution order:
| TransverseMercator
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, central_longitude=0.0, central_latitude=0.0, false_easting=0.0, false_northing=0.0, scale_factor=1.0, globe=None)
| Parameters
| ----------
| central_longitude: optional
| The true longitude of the central meridian in degrees.
| Defaults to 0.
| central_latitude: optional
| The true latitude of the planar origin in degrees. Defaults to 0.
| false_easting: optional
| X offset from the planar origin in metres. Defaults to 0.
| false_northing: optional
| Y offset from the planar origin in metres. Defaults to 0.
| scale_factor: optional
| Scale factor at the central meridian. Defaults to 1.
| globe: optional
| An instance of :class:`cartopy.crs.Globe`. If omitted, a default
| globe is created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
class UTM(Projection)
| Universal Transverse Mercator projection.
|
| Method resolution order:
| UTM
| Projection
| cartopy._crs.CRS
| builtins.object
|
| Methods defined here:
|
| __init__(self, zone, southern_hemisphere=False, globe=None)
| Parameters
| ----------
| zone
| The numeric zone of the UTM required.
| southern_hemisphere: optional
| Set to True if the zone is in the southern hemisphere. Defaults to
| False.
| globe: optional
| An instance of :class:`cartopy.crs.Globe`. If omitted, a default
| globe is created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| boundary
|
| threshold
|
| x_limits
|
| y_limits
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| ----------------------------------------------------------------------
| Methods inherited from Projection:
|
| project_geometry(self, geometry, src_crs=None)
| Project the given geometry into this projection.
|
| Parameters
| ----------
| geometry
| The geometry to (re-)project.
| src_crs: optional
| The source CRS. Defaults to None.
|
| If src_crs is None, the source CRS is assumed to be a geodetic
| version of the target CRS.
|
| Returns
| -------
| geometry
| The projected result (a shapely geometry).
|
| quick_vertices_transform(self, vertices, src_crs)
| Where possible, return a vertices array transformed to this CRS from
| the given vertices array of shape ``(n, 2)`` and the source CRS.
|
| Note
| ----
| This method may return None to indicate that the vertices cannot
| be transformed quickly, and a more complex geometry transformation
| is required (see :meth:`cartopy.crs.Projection.project_geometry`).
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Projection:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
|
| ccw_boundary
|
| cw_boundary
|
| domain
|
| ----------------------------------------------------------------------
| Methods inherited from cartopy._crs.CRS:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getstate__(...)
| Return the full state of this instance for reconstruction
| in ``__setstate__``.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(...)
| Hash the CRS based on its proj4_init string.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| __reduce__(...)
| Implement the __reduce__ API so that unpickling produces a stateless
| instance of this class (e.g. an empty tuple). The state will then be
| added via __getstate__ and __setstate__.
|
| __setstate__(...)
| Take the dictionary created by ``__getstate__`` and passes it
| through to the class's __init__ method.
|
| as_geocentric(...)
| Return a new Geocentric CRS with the same ellipse/datum as this
| CRS.
|
| as_geodetic(...)
| Return a new Geodetic CRS with the same ellipse/datum as this
| CRS.
|
| is_geodetic(...)
|
| transform_point(...)
| transform_point(x, y, src_crs)
|
| Transform the given float64 coordinate pair, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| x
| the x coordinate, in ``src_crs`` coordinates, to transform
| y
| the y coordinate, in ``src_crs`` coordinates, to transform
| src_crs
| instance of :class:`CRS` that represents the coordinate
| system of ``x`` and ``y``.
| trap
| Whether proj.4 errors for "latitude or longitude exceeded
| limits" and "tolerance condition error" should be trapped.
|
| Returns
| -------
| (x, y) in this coordinate system
|
| transform_points(...)
| transform_points(src_crs, x, y[, z])
|
| Transform the given coordinates, in the given source
| coordinate system (``src_crs``), to this coordinate system.
|
| Parameters
| ----------
| src_crs
| instance of :class:`CRS` that represents the
| coordinate system of ``x``, ``y`` and ``z``.
| x
| the x coordinates (array), in ``src_crs`` coordinates,
| to transform. May be 1 or 2 dimensional.
| y
| the y coordinates (array), in ``src_crs`` coordinates,
| to transform. Its shape must match that of x.
| z: optional
| the z coordinates (array), in ``src_crs`` coordinates, to
| transform. Defaults to None.
| If supplied, its shape must match that of x.
|
| Returns
| -------
| Array of shape ``x.shape + (3, )`` in this coordinate system.
|
| transform_vectors(...)
| transform_vectors(src_proj, x, y, u, v)
|
| Transform the given vector components, with coordinates in the
| given source coordinate system (``src_proj``), to this coordinate
| system. The vector components must be given relative to the
| source projection's coordinate reference system (grid eastward and
| grid northward).
|
| Parameters
| ----------
| src_proj
| The :class:`CRS.Projection` that represents the coordinate system
| the vectors are defined in.
| x
| The x coordinates of the vectors in the source projection.
| y
| The y coordinates of the vectors in the source projection.
| u
| The grid-eastward components of the vectors.
| v
| The grid-northward components of the vectors.
|
| Note
| ----
| x, y, u and v may be 1 or 2 dimensional, but must all have matching
| shapes.
|
| Returns
| -------
| ut, vt: The transformed vector components.
|
| Note
| ----
| The algorithm used to transform vectors is an approximation
| rather than an exact transform, but the accuracy should be
| good enough for visualization purposes.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from cartopy._crs.CRS:
|
| proj4_init
|
| proj4_params
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from cartopy._crs.CRS:
|
| __pyx_vtable__ = <capsule object NULL>
FUNCTIONS
epsg(code)
Return the projection which corresponds to the given EPSG code.
The EPSG code must correspond to a "projected coordinate system",
so EPSG codes such as 4326 (WGS-84) which define a "geodetic coordinate
system" will not work.
Note
----
The conversion is performed by querying https://epsg.io/ so a
live internet connection is required.
DATA
GOOGLE_MERCATOR = <cartopy.crs.Mercator object>
PROJ4_VERSION = (4, 9, 3)
WGS84_SEMIMAJOR_AXIS = 6378137.0
WGS84_SEMIMINOR_AXIS = 6356752.3142
__document_these__ = ['CRS', 'Geocentric', 'Geodetic', 'Globe']
absolute_import = _Feature((2, 5, 0, 'alpha', 1), (3, 0, 0, 'alpha', 0...
division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192...
print_function = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0)...
FILE
/Users/brodzik/miniconda3/envs/cartopy/lib/python3.6/site-packages/cartopy/crs.py
In [3]:
ccrs.PlateCarree()
Out[3]:
<cartopy.crs.PlateCarree at 0x11b4b16d0>
In [4]:
%matplotlib notebook
import matplotlib.pyplot as plt
plt.axes(projection=ccrs.PlateCarree())
Out[4]:
<cartopy.mpl.geoaxes.GeoAxesSubplot at 0x10f44f128>
In [5]:
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.coastlines()
Out[5]:
<cartopy.mpl.feature_artist.FeatureArtist at 0x11fa90e48>
In [ ]:
plt.figure()
ax = plt.axes(projection=ccrs.LambertAzimuthalEqualArea(central_latitude=90.))
ax.coastlines()
In [6]:
fig, ax = plt.subplots(subplot_kw=dict(projection=ccrs.PlateCarree(central_longitude=180.)))
ax.coastlines()
Out[6]:
<cartopy.mpl.feature_artist.FeatureArtist at 0x120808748>
In [7]:
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.set_extent([-170, -50, 10, 80])
ax.gridlines(draw_labels=True,
color='black', alpha=0.2, linestyle='--')
ax.stock_img()
Out[7]:
<matplotlib.image.AxesImage at 0x120c164a8>
In [8]:
%pwd
Out[8]:
'/Users/brodzik/ipython_notebooks/cartopy'
In [9]:
img = plt.imread('/Users/brodzik/cartopy-tutorial/resources/natural-earth-2/global.png')
print(img.shape)
(1000, 2000, 3)
In [10]:
import fiona
import shapely.geometry as sgeom
shpfile = '/Users/brodzik/cartopy-tutorial/resources/states/states.shp'
with fiona.open(shpfile) as records:
geometries = [sgeom.shape(shp['geometry'])
for shp in records]
In [11]:
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.set_extent([-170, -50, 10, 80])
ax.gridlines(draw_labels=True,
color='black', alpha=0.2, linestyle='--')
ax.imshow(img, origin='upper',
extent=[-180, 180, -90, 90],
transform=ccrs.PlateCarree())
ax.add_geometries(geometries, ccrs.PlateCarree(),
edgecolor='red', facecolor='none')
Out[11]:
<cartopy.mpl.feature_artist.FeatureArtist at 0x128850160>
In [12]:
new_york = dict(lon=-74.0060, lat=40.7128)
honolulu = dict(lon=-157.8583, lat=21.3069)
def new_york_to_honolulu(ax):
lons = [new_york['lon'], honolulu['lon']]
lats = [new_york['lat'], honolulu['lat']]
ax.plot(lons, lats, transform=ccrs.PlateCarree(),
label='Equirectangular straight line')
ax.plot(lons, lats, transform=ccrs.Geodetic(),
label='Great Circle')
ax.legend()
import cartopy.feature
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.set_extent([-170, -50, 10, 80])
ax.gridlines(color='black', alpha=0.2, linestyle='--')
ax.stock_img()
ax.add_feature(cartopy.feature.STATES, edgecolor='gray')
new_york_to_honolulu(ax)
In [ ]:
# Change the projection to one that represents great circles out of NYC as straight lines
# --> polar stereo centered on NYC
In [13]:
ny_stereo = ccrs.Stereographic(
central_longitude = new_york['lon'],
central_latitude = new_york['lat'])
plt.figure()
ax = plt.axes(projection=ny_stereo)
ax.set_extent([-170, -50, 10, 80])
ax.gridlines(color='black', alpha=0.2, linestyle='--')
ax.stock_img()
ax.add_feature(cartopy.feature.STATES, edgecolor='gray')
new_york_to_honolulu(ax)
In [14]:
class HigherResStereo(ccrs.Stereographic):
@property
def threshold(self):
# Give the interpolation 10x more fidelity
return super().threshold / 10
ny_stereo = HigherResStereo(
central_longitude = new_york['lon'],
central_latitude = new_york['lat'])
plt.figure()
ax = plt.axes(projection=ny_stereo)
ax.set_extent([-170, -50, 10, 80])
ax.gridlines(color='black', alpha=0.2, linestyle='--')
ax.stock_img()
ax.add_feature(cartopy.feature.STATES, edgecolor='gray')
new_york_to_honolulu(ax)
In [15]:
# Some approximate locations of each of the cities are provided.
places = {'London': {'lon': -0.1278, 'lat': 51.5074},
'Suez': {'lon': 32.5498, 'lat': 29.9668},
'Bombay': {'lon': 72.8777, 'lat': 19.0760},
'Calcutta': {'lon': 88.3639, 'lat': 22.5726},
'Hong Kong': {'lon': 114.1095, 'lat': 22.3964},
'Yokohama': {'lon': 139.6380, 'lat': 35.4437},
'San Fransisco': {'lon': -122.4194, 'lat': 37.7749},
'New York City': {'lon': -74.0060, 'lat': 40.7128},
}
In [30]:
places.keys()
Out[30]:
dict_keys(['London', 'Suez', 'Bombay', 'Calcutta', 'Hong Kong', 'Yokohama', 'San Fransisco', 'New York City'])
In [41]:
from_city = [key for key in places.keys()]
from_city
Out[41]:
['London',
'Suez',
'Bombay',
'Calcutta',
'Hong Kong',
'Yokohama',
'San Fransisco',
'New York City']
In [44]:
to_city = [key for key in places.keys()]
to_city.append(to_city[0])
to_city = to_city[1:]
to_city
Out[44]:
['Suez',
'Bombay',
'Calcutta',
'Hong Kong',
'Yokohama',
'San Fransisco',
'New York City',
'London']
In [45]:
for src, dst in zip(from_city, to_city):
print(src, ":", dst)
London : Suez
Suez : Bombay
Bombay : Calcutta
Calcutta : Hong Kong
Hong Kong : Yokohama
Yokohama : San Fransisco
San Fransisco : New York City
New York City : London
In [51]:
plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.gridlines(color='black', alpha=0.2, linestyle='--')
ax.stock_img()
for src, dst in zip(from_city, to_city):
ax.plot([places[src]['lon'], places[dst]['lon']],
[places[src]['lat'], places[dst]['lat']],
transform=ccrs.Geodetic(),
label="%s->%s" % (src, dst),
color="red" )
ax.annotate(s=src, xy = [places[src]['lon'], places[src]['lat']])
#ax.legend()
Exercise 2.3: Navigate to the cartopy documentation for the Robinson projection. Draw a Robinson map (with coastlines) that represents the "centered on the meridian circa 11°15' (11.25 degrees) to east from Greenwich Prime Meridian" part of this definition.
In [54]:
plt.figure()
ax = plt.axes(projection=ccrs.Robinson(central_longitude=11.25))
ax.gridlines(color='black', alpha=0.2, linestyle='--')
ax.stock_img()
ax.coastlines()
Out[54]:
<cartopy.mpl.feature_artist.FeatureArtist at 0x12bfa3c50>
In [62]:
# [xmin, xmax,
# ymin, ymax] Are these in projected meteres?
extent = [-13636707, 17044670,
-6308712, 8565930]
plt.figure()
rob = ccrs.Robinson(central_longitude=11.25)
ax = plt.axes(projection=rob)
ax.gridlines(color='gray', linestyle='--')
ax.coastlines()
img = plt.imread('/Users/brodzik/cartopy-tutorial/resources/640px-Around_the_World_in_Eighty_Days_map.png')
#ax.imshow(img, transform=rob)
ax.imshow(img, extent=extent, transform=rob, origin='upper')
ax.set_global()
In [ ]:
Content source: mjbrodzik/ipython_notebooks
Similar notebooks: