def _pcolormesh2_internal(ax, X, Y, C, cmap, norm):
X[X >= 180] -= 360
am, pm, boxes_xy_pc = get_am_and_pm_masks_and_polygons_outline(X, Y)
center_i = int(X.shape[0] / 2)
center_j = int(X.shape[1] / 2)
cX = X[center_i, center_j]
cY = Y[center_i, center_j]
gnomonic_crs = ccrs.Gnomonic(cY, cX)
gnomonic_proj = pyproj.Proj(gnomonic_crs.proj4_init)
X_gno, Y_gno = gnomonic_proj(X, Y)
boxes_xy_gno = np.moveaxis(gnomonic_proj(boxes_xy_pc[..., 0], boxes_xy_pc[..., 1]), 0, -1)
if np.any(np.isnan(X_gno)) or np.any(np.isnan(Y_gno)):
raise ValueError('Block size is too big!')
else:
plt.pcolormesh(X_gno, Y_gno, np.ma.masked_array(C, ~am), transform=gnomonic_crs, cmap=cmap, norm=norm)
for idx in np.argwhere(~am):
c = cmap(norm(C[idx[0], idx[1]]))
ax.add_geometries(
[shapely.geometry.Polygon(boxes_xy_gno[idx[0], idx[1],...])],
gnomonic_crs, edgecolor=c, facecolor=c
)
def test_default():
gnom = ccrs.Gnomonic()
other_args = {'a=6378137.0', 'lon_0=0.0', 'lat_0=0.0'}
check_proj_params('gnom', gnom, other_args)
assert_almost_equal(np.array(gnom.x_limits), [-5e7, 5e7])
assert_almost_equal(np.array(gnom.y_limits), [-5e7, 5e7])
def test_central_params(lat, lon):
gnom = ccrs.Gnomonic(central_latitude=lat, central_longitude=lon)
other_args = {f'lat_0={lat}', f'lon_0={lon}', 'a=6378137.0'}
check_proj_params('gnom', gnom, other_args)
assert_almost_equal(np.array(gnom.x_limits), [-5e7, 5e7])
assert_almost_equal(np.array(gnom.y_limits), [-5e7, 5e7])
def test_default():
gnom = ccrs.Gnomonic()
other_args = {'ellps=WGS84', 'lon_0=0.0', 'lat_0=0.0'}
check_proj4_params(gnom, other_args)
assert_almost_equal(np.array(gnom.x_limits), [-5e7, 5e7])
assert_almost_equal(np.array(gnom.y_limits), [-5e7, 5e7])
def test_grid():
# USGS Professional Paper 1395, pg 168, Table 26
globe = ccrs.Globe(ellipse=None, semimajor_axis=1.0, semiminor_axis=1.0)
gnom = ccrs.Gnomonic(globe=globe)
geodetic = gnom.as_geodetic()
other_args = {'a=1.0', 'b=1.0', 'lon_0=0.0', 'lat_0=0.0'}
check_proj_params('gnom', gnom, other_args)
assert_almost_equal(np.array(gnom.x_limits), [-5e7, 5e7])
assert_almost_equal(np.array(gnom.y_limits), [-5e7, 5e7])
lats, lons = np.mgrid[0:90:10, 0:90:10].reshape((2, -1))
expected_x = np.tile([
0.0000, 0.1763, 0.3640, 0.5774, 0.8391, 1.1918, 1.7321, 2.7475, 5.6713
], 9)
expected_y = np.array([
[5.6713, 2.7475, 1.7321, 1.1918, 0.8391, 0.5774, 0.3640, 0.1763, 0],
[5.7588, 2.7899, 1.7588, 1.2101, 0.8520, 0.5863, 0.3696, 0.1790, 0],
[6.0353, 2.9238, 1.8432, 1.2682, 0.8930, 0.6144, 0.3873, 0.1876, 0],
[6.5486, 3.1725, 2.0000, 1.3761, 0.9689, 0.6667, 0.4203, 0.2036, 0],
[7.4033, 3.5866, 2.2610, 1.5557, 1.0954, 0.7537, 0.4751, 0.2302, 0],
[8.8229, 4.2743, 2.6946, 1.8540, 1.3054, 0.8982, 0.5662, 0.2743, 0],
[11.3426, 5.4950, 3.4641, 2.3835, 1.6782, 1.1547, 0.7279, 0.3527, 0],
[16.5817, 8.0331, 5.0642, 3.4845, 2.4534, 1.6881, 1.0642, 0.5155, 0],
[32.6596, 15.8221, 9.9745, 6.8630, 4.8322, 3.3248, 2.0960, 1.0154, 0],
])[:, ::-1].T.ravel()
# Test all quadrants; they are symmetrical.
for lon_sign in [1, -1]:
for lat_sign in [1, -1]:
result = gnom.transform_points(geodetic, lon_sign * lons,
lat_sign * lats)
assert_almost_equal(result[:, 0], lon_sign * expected_x, decimal=4)
assert_almost_equal(result[:, 1], lat_sign * expected_y, decimal=4)
def test_sphere_globe():
globe = ccrs.Globe(semimajor_axis=1000, ellipse=None)
gnom = ccrs.Gnomonic(globe=globe)
other_args = {'a=1000', 'lon_0=0.0', 'lat_0=0.0'}
check_proj_params('gnom', gnom, other_args)
assert_almost_equal(gnom.x_limits, [-5e7, 5e7])
assert_almost_equal(gnom.y_limits, [-5e7, 5e7])
def test_central_params(lat, lon):
gnom = ccrs.Gnomonic(central_latitude=lat, central_longitude=lon)
other_args = {
'lat_0={}'.format(lat), 'lon_0={}'.format(lon), 'ellps=WGS84'
}
check_proj4_params(gnom, other_args)
assert_almost_equal(np.array(gnom.x_limits), [-5e7, 5e7])
assert_almost_equal(np.array(gnom.y_limits), [-5e7, 5e7])
def test_ellipse_globe():
globe = ccrs.Globe(ellipse='WGS84')
with pytest.warns(UserWarning,
match='does not handle elliptical globes.') as w:
gnom = ccrs.Gnomonic(globe=globe)
assert len(w) == 1
other_args = {'ellps=WGS84', 'lon_0=0.0', 'lat_0=0.0'}
check_proj_params('gnom', gnom, other_args)
# Limits are the same as default since ellipses are not supported.
assert_almost_equal(gnom.x_limits, [-5e7, 5e7])
assert_almost_equal(gnom.y_limits, [-5e7, 5e7])
def test_eccentric_globe():
globe = ccrs.Globe(semimajor_axis=1000, semiminor_axis=500, ellipse=None)
with pytest.warns(UserWarning,
match='does not handle elliptical globes.') as w:
gnom = ccrs.Gnomonic(globe=globe)
assert len(w) == 1
other_args = {'a=1000', 'b=500', 'lon_0=0.0', 'lat_0=0.0'}
check_proj_params('gnom', gnom, other_args)
# Limits are the same as spheres since ellipses are not supported.
assert_almost_equal(gnom.x_limits, [-5e7, 5e7])
assert_almost_equal(gnom.y_limits, [-5e7, 5e7])
def test_multiple_projections():
projections = [
ccrs.PlateCarree(),
ccrs.Robinson(),
ccrs.RotatedPole(pole_latitude=45, pole_longitude=180),
ccrs.OSGB(approx=True),
ccrs.TransverseMercator(approx=True),
ccrs.Mercator(globe=ccrs.Globe(semimajor_axis=math.degrees(1)),
min_latitude=-85.,
max_latitude=85.),
ccrs.LambertCylindrical(),
ccrs.Miller(),
ccrs.Gnomonic(),
ccrs.Stereographic(),
ccrs.NorthPolarStereo(),
ccrs.SouthPolarStereo(),
ccrs.Orthographic(),
ccrs.Mollweide(),
ccrs.InterruptedGoodeHomolosine(emphasis='land'),
ccrs.EckertI(),
ccrs.EckertII(),
ccrs.EckertIII(),
ccrs.EckertIV(),
ccrs.EckertV(),
ccrs.EckertVI(),
]
rows = np.ceil(len(projections) / 5).astype(int)
fig = plt.figure(figsize=(10, 2 * rows))
for i, prj in enumerate(projections, 1):
ax = fig.add_subplot(rows, 5, i, projection=prj)
ax.set_global()
ax.coastlines(resolution="110m")
plt.plot(-0.08, 51.53, 'o', transform=ccrs.PlateCarree())
plt.plot([-0.08, 132], [51.53, 43.17],
color='red',
transform=ccrs.PlateCarree())
plt.plot([-0.08, 132], [51.53, 43.17],
color='blue',
transform=ccrs.Geodetic())
def test_multiple_projections():
projections = [
ccrs.PlateCarree(),
ccrs.Robinson(),
ccrs.RotatedPole(pole_latitude=45, pole_longitude=180),
ccrs.OSGB(),
ccrs.TransverseMercator(),
ccrs.Mercator(globe=ccrs.Globe(semimajor_axis=math.degrees(1)),
min_latitude=-85.,
max_latitude=85.),
ccrs.LambertCylindrical(),
ccrs.Miller(),
ccrs.Gnomonic(),
ccrs.Stereographic(),
ccrs.NorthPolarStereo(),
ccrs.SouthPolarStereo(),
ccrs.Orthographic(),
ccrs.Mollweide(),
ccrs.InterruptedGoodeHomolosine(),
]
if ccrs.PROJ4_VERSION < (5, 0, 0):
# Produce the same sized image for old proj, to avoid having to replace
# the image. If this figure is regenerated for both old and new proj,
# then drop this condition.
rows = 5
else:
rows = np.ceil(len(projections) / 5)
fig = plt.figure(figsize=(10, 2 * rows))
for i, prj in enumerate(projections, 1):
ax = fig.add_subplot(rows, 5, i, projection=prj)
ax.set_global()
ax.coastlines()
plt.plot(-0.08, 51.53, 'o', transform=ccrs.PlateCarree())
plt.plot([-0.08, 132], [51.53, 43.17],
color='red',
transform=ccrs.PlateCarree())
plt.plot([-0.08, 132], [51.53, 43.17],
color='blue',
transform=ccrs.Geodetic())
def _make_rings(self):
self._face_polygon = 6 * [None]
self._gnomonic_proj = 6 * [None]
for i in range(6):
xe = self.xe(i)
ye = self.ye(i)
center = ((np.array(xe.shape) + 0.5) / 2).astype(int)
xc = xe[center[0], center[1]]
yc = ye[center[0], center[1]]
self._gnomonic_proj[i] = pyproj.Proj(
ccrs.Gnomonic(central_longitude=xc,
central_latitude=yc).proj4_init)
ring_x, ring_y = self._gnomonic_proj[i](
np.array([xe[0, 0], xe[0, -1], xe[-1, -1], xe[-1, 0]]),
np.array([ye[0, 0], ye[0, -1], ye[-1, -1], ye[-1, 0]]))
self._face_polygon[i] = shapely.geometry.Polygon(
[*zip(ring_x[::-1], ring_y[::-1])])
def test_nearest_gnomonic_uk_domain(self):
crs = ccrs.Gnomonic(central_latitude=60.0)
uk_grid = self.global_grid.intersection(longitude=(-20, 20),
latitude=(40, 80))
res = self.src.regrid(uk_grid, ProjectedUnstructuredNearest(crs))
self.assertArrayShapeStats(res, (1, 6, 17, 11),
315.8873266,
11.0006664668,
rtol=1e-8)
self.assertArrayShapeStats(res[:, 0], (1, 17, 11), 299.99993826,
4.1356150388e-5)
expected_subset = np.array([[318.936829, 318.936829, 318.936829],
[318.936829, 318.936829, 318.936829],
[318.935163, 318.935163, 318.935163]])
self.assertArrayAlmostEqual(expected_subset, res.data[0, 3, 5:8,
4:7].data)
def test_sphere_transform():
# USGS Professional Paper 1395, pp 319 - 320
globe = ccrs.Globe(semimajor_axis=1.0, semiminor_axis=1.0, ellipse=None)
gnom = ccrs.Gnomonic(central_latitude=40.0,
central_longitude=-100.0,
globe=globe)
geodetic = gnom.as_geodetic()
other_args = {'a=1.0', 'b=1.0', 'lon_0=-100.0', 'lat_0=40.0'}
check_proj_params('gnom', gnom, other_args)
assert_almost_equal(np.array(gnom.x_limits), [-5e7, 5e7])
assert_almost_equal(np.array(gnom.y_limits), [-5e7, 5e7])
result = gnom.transform_point(-110.0, 30.0, geodetic)
assert_almost_equal(result, np.array([-0.1542826, -0.1694739]))
inverse_result = geodetic.transform_point(result[0], result[1], gnom)
assert_almost_equal(inverse_result, [-110.0, 30.0])
def enhance_gridbox_edges(box_xy: np.array, res):
temp_proj = pyproj.Proj(
ccrs.Gnomonic(central_longitude=np.mean(box_xy[:, 0]),
central_latitude=np.mean(box_xy[:, 1])).proj4_init)
new_x = []
new_y = []
for (seg_x0, seg_y0), (seg_x1, seg_y1) in zip(box_xy[:-1, :],
box_xy[1:, :]):
seg_length = np.sqrt((seg_x1 - seg_x0)**2 + (seg_y1 - seg_y0)**2)
gx, gy = temp_proj([seg_x0, seg_x1], [seg_y0, seg_y1])
m = (gy[1] - gy[0]) / (gx[1] - gx[0])
b = gy[0] - m * gx[0]
interped_gx = np.linspace(gx[0], gx[1], res)
interped_gy = m * interped_gx + b
x, y = temp_proj(interped_gx, interped_gy, inverse=True)
new_x.extend(x)
new_y.extend(y)
new_x.append(new_x[0])
new_y.append(new_y[0])
new_xy = np.moveaxis(np.array([new_x, new_y]), 0, -1)
return new_xy
def test_multiple_projections():
projections = [
ccrs.PlateCarree(),
ccrs.Robinson(),
ccrs.RotatedPole(pole_latitude=45, pole_longitude=180),
ccrs.OSGB(),
ccrs.TransverseMercator(),
ccrs.Mercator(globe=ccrs.Globe(semimajor_axis=math.degrees(1)),
min_latitude=-85.,
max_latitude=85.),
ccrs.LambertCylindrical(),
ccrs.Miller(),
ccrs.Gnomonic(),
ccrs.Stereographic(),
ccrs.NorthPolarStereo(),
ccrs.SouthPolarStereo(),
ccrs.Orthographic(),
ccrs.Mollweide(),
ccrs.InterruptedGoodeHomolosine(),
]
fig = plt.figure(figsize=(10, 10))
for i, prj in enumerate(projections, 1):
ax = fig.add_subplot(5, 5, i, projection=prj)
ax.set_global()
ax.coastlines()
plt.plot(-0.08, 51.53, 'o', transform=ccrs.PlateCarree())
plt.plot([-0.08, 132], [51.53, 43.17],
color='red',
transform=ccrs.PlateCarree())
plt.plot([-0.08, 132], [51.53, 43.17],
color='blue',
transform=ccrs.Geodetic())
def set_proj(projection='Robinson', proj_default=True):
""" Set the projection for Cartopy.
Parameters
----------
projection : string
the map projection. Available projections:
'Robinson' (default), 'PlateCarree', 'AlbertsEqualArea',
'AzimuthalEquidistant','EquidistantConic','LambertConformal',
'LambertCylindrical','Mercator','Miller','Mollweide','Orthographic',
'Sinusoidal','Stereographic','TransverseMercator','UTM',
'InterruptedGoodeHomolosine','RotatedPole','OSGB','EuroPP',
'Geostationary','NearsidePerspective','EckertI','EckertII',
'EckertIII','EckertIV','EckertV','EckertVI','EqualEarth','Gnomonic',
'LambertAzimuthalEqualArea','NorthPolarStereo','OSNI','SouthPolarStereo'
proj_default : bool
If True, uses the standard projection attributes from Cartopy.
Enter new attributes in a dictionary to change them. Lists of attributes
can be found in the Cartopy documentation:
https://scitools.org.uk/cartopy/docs/latest/crs/projections.html#eckertiv
Returns
-------
proj : the Cartopy projection object
See Also
--------
pyleoclim.utils.mapping.map_all : mapping function making use of the projection
"""
if proj_default is not True and type(proj_default) is not dict:
raise TypeError(
'The default for the projections should either be provided' +
' as a dictionary or set to True')
# Set the projection
if projection == 'Robinson':
if proj_default is True:
proj = ccrs.Robinson()
else:
proj = ccrs.Robinson(**proj_default)
elif projection == 'PlateCarree':
if proj_default is True:
proj = ccrs.PlateCarree()
else:
proj = ccrs.PlateCarree(**proj_default)
elif projection == 'AlbersEqualArea':
if proj_default is True:
proj = ccrs.AlbersEqualArea()
else:
proj = ccrs.AlbersEqualArea(**proj_default)
elif projection == 'AzimuthalEquidistant':
if proj_default is True:
proj = ccrs.AzimuthalEquidistant()
else:
proj = ccrs.AzimuthalEquidistant(**proj_default)
elif projection == 'EquidistantConic':
if proj_default is True:
proj = ccrs.EquidistantConic()
else:
proj = ccrs.EquidistantConic(**proj_default)
elif projection == 'LambertConformal':
if proj_default is True:
proj = ccrs.LambertConformal()
else:
proj = ccrs.LambertConformal(**proj_default)
elif projection == 'LambertCylindrical':
if proj_default is True:
proj = ccrs.LambertCylindrical()
else:
proj = ccrs.LambertCylindrical(**proj_default)
elif projection == 'Mercator':
if proj_default is True:
proj = ccrs.Mercator()
else:
proj = ccrs.Mercator(**proj_default)
elif projection == 'Miller':
if proj_default is True:
proj = ccrs.Miller()
else:
proj = ccrs.Miller(**proj_default)
elif projection == 'Mollweide':
if proj_default is True:
proj = ccrs.Mollweide()
else:
proj = ccrs.Mollweide(**proj_default)
elif projection == 'Orthographic':
if proj_default is True:
proj = ccrs.Orthographic()
else:
proj = ccrs.Orthographic(**proj_default)
elif projection == 'Sinusoidal':
if proj_default is True:
proj = ccrs.Sinusoidal()
else:
proj = ccrs.Sinusoidal(**proj_default)
elif projection == 'Stereographic':
if proj_default is True:
proj = ccrs.Stereographic()
else:
proj = ccrs.Stereographic(**proj_default)
elif projection == 'TransverseMercator':
if proj_default is True:
proj = ccrs.TransverseMercator()
else:
proj = ccrs.TransverseMercator(**proj_default)
elif projection == 'TransverseMercator':
if proj_default is True:
proj = ccrs.TransverseMercator()
else:
proj = ccrs.TransverseMercator(**proj_default)
elif projection == 'UTM':
if proj_default is True:
proj = ccrs.UTM()
else:
proj = ccrs.UTM(**proj_default)
elif projection == 'UTM':
if proj_default is True:
proj = ccrs.UTM()
else:
proj = ccrs.UTM(**proj_default)
elif projection == 'InterruptedGoodeHomolosine':
if proj_default is True:
proj = ccrs.InterruptedGoodeHomolosine()
else:
proj = ccrs.InterruptedGoodeHomolosine(**proj_default)
elif projection == 'RotatedPole':
if proj_default is True:
proj = ccrs.RotatedPole()
else:
proj = ccrs.RotatedPole(**proj_default)
elif projection == 'OSGB':
if proj_default is True:
proj = ccrs.OSGB()
else:
proj = ccrs.OSGB(**proj_default)
elif projection == 'EuroPP':
if proj_default is True:
proj = ccrs.EuroPP()
else:
proj = ccrs.EuroPP(**proj_default)
elif projection == 'Geostationary':
if proj_default is True:
proj = ccrs.Geostationary()
else:
proj = ccrs.Geostationary(**proj_default)
elif projection == 'NearsidePerspective':
if proj_default is True:
proj = ccrs.NearsidePerspective()
else:
proj = ccrs.NearsidePerspective(**proj_default)
elif projection == 'EckertI':
if proj_default is True:
proj = ccrs.EckertI()
else:
proj = ccrs.EckertI(**proj_default)
elif projection == 'EckertII':
if proj_default is True:
proj = ccrs.EckertII()
else:
proj = ccrs.EckertII(**proj_default)
elif projection == 'EckertIII':
if proj_default is True:
proj = ccrs.EckertIII()
else:
proj = ccrs.EckertIII(**proj_default)
elif projection == 'EckertIV':
if proj_default is True:
proj = ccrs.EckertIV()
else:
proj = ccrs.EckertIV(**proj_default)
elif projection == 'EckertV':
if proj_default is True:
proj = ccrs.EckertV()
else:
proj = ccrs.EckertV(**proj_default)
elif projection == 'EckertVI':
if proj_default is True:
proj = ccrs.EckertVI()
else:
proj = ccrs.EckertVI(**proj_default)
elif projection == 'EqualEarth':
if proj_default is True:
proj = ccrs.EqualEarth()
else:
proj = ccrs.EqualEarth(**proj_default)
elif projection == 'Gnomonic':
if proj_default is True:
proj = ccrs.Gnomonic()
else:
proj = ccrs.Gnomonic(**proj_default)
elif projection == 'LambertAzimuthalEqualArea':
if proj_default is True:
proj = ccrs.LambertAzimuthalEqualArea()
else:
proj = ccrs.LambertAzimuthalEqualArea(**proj_default)
elif projection == 'NorthPolarStereo':
if proj_default is True:
proj = ccrs.NorthPolarStereo()
else:
proj = ccrs.NorthPolarStereo(**proj_default)
elif projection == 'OSNI':
if proj_default is True:
proj = ccrs.OSNI()
else:
proj = ccrs.OSNI(**proj_default)
elif projection == 'OSNI':
if proj_default is True:
proj = ccrs.SouthPolarStereo()
else:
proj = ccrs.SouthPolarStereo(**proj_default)
else:
raise ValueError('Invalid projection type')
return proj
def to_cartopy_proj(self):
"""
Creates a `cartopy.crs.Projection` instance from PROJ4 parameters.
Returns
-------
cartopy.crs.projection
Cartopy projection representing the projection of the spatial reference system.
"""
proj4_params = self.to_proj4_dict()
proj4_name = proj4_params.get('proj')
central_longitude = proj4_params.get('lon_0', 0.)
central_latitude = proj4_params.get('lat_0', 0.)
false_easting = proj4_params.get('x_0', 0.)
false_northing = proj4_params.get('y_0', 0.)
scale_factor = proj4_params.get('k', 1.)
standard_parallels = (proj4_params.get('lat_1', 20.),
proj4_params.get('lat_2', 50.))
if proj4_name == 'longlat':
ccrs_proj = ccrs.PlateCarree(central_longitude)
elif proj4_name == 'aeqd':
ccrs_proj = ccrs.AzimuthalEquidistant(central_longitude,
central_latitude,
false_easting,
false_northing)
elif proj4_name == 'merc':
ccrs_proj = ccrs.Mercator(central_longitude,
false_easting=false_easting,
false_northing=false_northing,
scale_factor=scale_factor)
elif proj4_name == 'eck1':
ccrs_proj = ccrs.EckertI(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck2':
ccrs_proj = ccrs.EckertII(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck3':
ccrs_proj = ccrs.EckertIII(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck4':
ccrs_proj = ccrs.EckertIV(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck5':
ccrs_proj = ccrs.EckertV(central_longitude, false_easting,
false_northing)
elif proj4_name == 'eck6':
ccrs_proj = ccrs.EckertVI(central_longitude, false_easting,
false_northing)
elif proj4_name == 'aea':
ccrs_proj = ccrs.AlbersEqualArea(central_longitude,
central_latitude, false_easting,
false_northing,
standard_parallels)
elif proj4_name == 'eqdc':
ccrs_proj = ccrs.EquidistantConic(central_longitude,
central_latitude, false_easting,
false_northing,
standard_parallels)
elif proj4_name == 'gnom':
ccrs_proj = ccrs.Gnomonic(central_longitude, central_latitude)
elif proj4_name == 'laea':
ccrs_proj = ccrs.LambertAzimuthalEqualArea(central_longitude,
central_latitude,
false_easting,
false_northing)
elif proj4_name == 'lcc':
ccrs_proj = ccrs.LambertConformal(
central_longitude,
central_latitude,
false_easting,
false_northing,
standard_parallels=standard_parallels)
elif proj4_name == 'mill':
ccrs_proj = ccrs.Miller(central_longitude)
elif proj4_name == 'moll':
ccrs_proj = ccrs.Mollweide(central_longitude,
false_easting=false_easting,
false_northing=false_northing)
elif proj4_name == 'stere':
ccrs_proj = ccrs.Stereographic(central_latitude,
central_longitude,
false_easting,
false_northing,
scale_factor=scale_factor)
elif proj4_name == 'ortho':
ccrs_proj = ccrs.Orthographic(central_longitude, central_latitude)
elif proj4_name == 'robin':
ccrs_proj = ccrs.Robinson(central_longitude,
false_easting=false_easting,
false_northing=false_northing)
elif proj4_name == 'sinus':
ccrs_proj = ccrs.Sinusoidal(central_longitude, false_easting,
false_northing)
elif proj4_name == 'tmerc':
ccrs_proj = ccrs.TransverseMercator(central_longitude,
central_latitude,
false_easting, false_northing,
scale_factor)
else:
err_msg = "Projection '{}' is not supported.".format(proj4_name)
raise ValueError(err_msg)
return ccrs_proj
fig = plt.figure(figsize=(fig_size, fig_size))
ax = plt.axes(projection=ccrs.Orthographic(central_latitude=0,
central_longitude=0))
coord_sys = cs.GeogCS(6371229)
if (projection == "Mollweide"):
fig = plt.figure(figsize=(fig_size, fig_size))
ax = plt.axes(projection=ccrs.Mollweide())
coord_sys = cs.GeogCS(6371229)
if (projection == "EckertIII"):
fig = plt.figure(figsize=(fig_size, 0.5 * fig_size))
ax = plt.axes(projection=ccrs.EckertIII())
coord_sys = cs.GeogCS(6371229)
if (projection == "Gnomonic"):
fig = plt.figure(figsize=(fig_size, fig_size))
proj = ccrs.Gnomonic(central_latitude=desired_lat_deg,
central_longitude=desired_lon_deg,
globe=None)
ax = plt.axes(projection=proj)
ax.set_extent(
[-width_map / 2, width_map / 2, -height_map / 2, height_map / 2],
crs=proj)
if (projection == "Stereographic"):
fig = plt.figure(figsize=(fig_size, fig_size))
if scope == "ARCTIC":
proj = ccrs.NorthPolarStereo()
ax = plt.axes(projection=proj)
ax.set_extent([-180, 180, 40, 90], crs=ccrs.PlateCarree())
if scope == "ANTARCTIC":
proj = ccrs.SouthPolarStereo()
ax = plt.axes(projection=proj)
ax.set_extent([-180, 180, -40, -90], crs=ccrs.PlateCarree())
import matplotlib.pyplot as plt
import cartopy.crs as ccrs
plt.figure(figsize=(3.0, 3))
delta = 0.125
ax = plt.axes([0 + delta, 0 + delta, 1 - delta, 1 - delta],
projection=ccrs.Gnomonic())
#ax.set_global()
ax.coastlines()
ax.gridlines()
'Sinusoidal': ccrs.Sinusoidal(),
'Stereographic': ccrs.Stereographic(),
'TransverseMercator': ccrs.TransverseMercator(),
'InterruptedGoodeHomolosine': ccrs.InterruptedGoodeHomolosine(),
'RotatedPole': ccrs.RotatedPole(),
'OSGB': ccrs.OSGB(),
'EuroPP': ccrs.EuroPP(),
'Geostationary': ccrs.Geostationary(),
'NearsidePerspective': ccrs.NearsidePerspective(),
'EckertI': ccrs.EckertI(),
'EckertII': ccrs.EckertII(),
'EckertIII': ccrs.EckertIII(),
'EckertIV': ccrs.EckertIV(),
'EckertV': ccrs.EckertV(),
'EckertVI': ccrs.EckertVI(),
'Gnomonic': ccrs.Gnomonic(),
'LambertAzimuthalEqualArea': ccrs.LambertAzimuthalEqualArea(),
'NorthPolarStereo': ccrs.NorthPolarStereo(),
'OSNI': ccrs.OSNI(),
'SouthPolarStereo': ccrs.SouthPolarStereo()
}
for index, projection in enumerate(projections.items()):
ax = fig.add_subplot(7, 5, index + 1, projection=projection[1])
ax.coastlines()
ax.set_title(projection[0])
plt.show()
# ~ #***********************************************************************
# ~ # CARTE + GRILLE LATITUDE LONGITUDE
def projection(self):
if self.proj is None:
return ccrs.PlateCarree()
proj_dict = ast.literal_eval(self.proj)
user_proj = proj_dict.pop("proj")
if user_proj == 'PlateCarree':
self.xylim_supported = True
return ccrs.PlateCarree(**proj_dict)
elif user_proj == 'AlbersEqualArea':
return ccrs.AlbersEqualArea(**proj_dict)
elif user_proj == 'AzimuthalEquidistant':
return ccrs.AzimuthalEquidistant(**proj_dict)
elif user_proj == 'EquidistantConic':
return ccrs.EquidistantConic(**proj_dict)
elif user_proj == 'LambertConformal':
return ccrs.LambertConformal(**proj_dict)
elif user_proj == 'LambertCylindrical':
return ccrs.LambertCylindrical(**proj_dict)
elif user_proj == 'Mercator':
return ccrs.Mercator(**proj_dict)
elif user_proj == 'Miller':
return ccrs.Miller(**proj_dict)
elif user_proj == 'Mollweide':
return ccrs.Mollweide(**proj_dict)
elif user_proj == 'Orthographic':
return ccrs.Orthographic(**proj_dict)
elif user_proj == 'Robinson':
return ccrs.Robinson(**proj_dict)
elif user_proj == 'Sinusoidal':
return ccrs.Sinusoidal(**proj_dict)
elif user_proj == 'Stereographic':
return ccrs.Stereographic(**proj_dict)
elif user_proj == 'TransverseMercator':
return ccrs.TransverseMercator(**proj_dict)
elif user_proj == 'UTM':
return ccrs.UTM(**proj_dict)
elif user_proj == 'InterruptedGoodeHomolosine':
return ccrs.InterruptedGoodeHomolosine(**proj_dict)
elif user_proj == 'RotatedPole':
return ccrs.RotatedPole(**proj_dict)
elif user_proj == 'OSGB':
self.xylim_supported = False
return ccrs.OSGB(**proj_dict)
elif user_proj == 'EuroPP':
self.xylim_supported = False
return ccrs.EuroPP(**proj_dict)
elif user_proj == 'Geostationary':
return ccrs.Geostationary(**proj_dict)
elif user_proj == 'NearsidePerspective':
return ccrs.NearsidePerspective(**proj_dict)
elif user_proj == 'EckertI':
return ccrs.EckertI(**proj_dict)
elif user_proj == 'EckertII':
return ccrs.EckertII(**proj_dict)
elif user_proj == 'EckertIII':
return ccrs.EckertIII(**proj_dict)
elif user_proj == 'EckertIV':
return ccrs.EckertIV(**proj_dict)
elif user_proj == 'EckertV':
return ccrs.EckertV(**proj_dict)
elif user_proj == 'EckertVI':
return ccrs.EckertVI(**proj_dict)
elif user_proj == 'EqualEarth':
return ccrs.EqualEarth(**proj_dict)
elif user_proj == 'Gnomonic':
return ccrs.Gnomonic(**proj_dict)
elif user_proj == 'LambertAzimuthalEqualArea':
return ccrs.LambertAzimuthalEqualArea(**proj_dict)
elif user_proj == 'NorthPolarStereo':
return ccrs.NorthPolarStereo(**proj_dict)
elif user_proj == 'OSNI':
return ccrs.OSNI(**proj_dict)
elif user_proj == 'SouthPolarStereo':
return ccrs.SouthPolarStereo(**proj_dict)
import matplotlib.pyplot as plt import cartopy.crs as ccrs plt.figure(figsize=(3, 3)) ax = plt.axes(projection=ccrs.Gnomonic()) ax.coastlines(resolution='110m') ax.gridlines()
def get_map_projection(
proj_name,
central_longitude=0.0,
central_latitude=0.0,
false_easting=0.0,
false_northing=0.0,
globe=None,
standard_parallels=(20.0, 50.0),
scale_factor=None,
min_latitude=-80.0,
max_latitude=84.0,
true_scale_latitude=None,
latitude_true_scale=None, ### BOTH
secant_latitudes=None,
pole_longitude=0.0,
pole_latitude=90.0,
central_rotated_longitude=0.0,
sweep_axis='y',
satellite_height=35785831,
cutoff=-30,
approx=None,
southern_hemisphere=False,
zone=15): #### numeric UTM zone
proj_name = proj_name.lower()
if (proj_name == 'albersequalarea'):
proj = ccrs.AlbersEqualArea(central_longitude=central_longitude,
central_latitude=central_latitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
standard_parallels=standard_parallels)
elif (proj_name == 'azimuthalequidistant'):
proj = ccrs.AzimuthalEquidistant(central_longitude=central_longitude,
central_latitude=central_latitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'equidistantconic'):
proj = ccrs.EquidistantConic(central_longitude=central_longitude,
central_latitude=central_latitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
standard_parallels=standard_parallels)
elif (proj_name == 'lambertconformal'):
proj = ccrs.LambertConformal(
central_longitude=-96.0, ##########
central_latitude=39.0, ##########
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
secant_latitudes=None,
standard_parallels=None, ## default: (33,45)
cutoff=cutoff)
elif (proj_name == 'lambertcylindrical'):
proj = ccrs.LambertCylindrical(central_longitude=central_longitude)
elif (proj_name == 'mercator'):
proj = ccrs.Mercator(central_longitude=central_longitude,
min_latitude=min_latitude,
max_latitude=max_latitude,
latitude_true_scale=latitude_true_scale,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
scale_factor=None) #########
elif (proj_name == 'miller'):
proj = ccrs.Miller(central_longitude=central_longitude, globe=globe)
elif (proj_name == 'mollweide'):
proj = ccrs.Mollweide(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'orthographic'):
proj = ccrs.Orthographic(central_longitude=central_longitude,
central_latitude=central_latitude,
globe=globe)
elif (proj_name == 'robinson'):
proj = ccrs.Robinson(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'sinusoidal'):
proj = ccrs.Sinusoidal(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'stereographic'):
proj = ccrs.Stereographic(central_latitude=central_latitude,
central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
true_scale_latitude=true_scale_latitude,
scale_factor=scale_factor)
elif (proj_name == 'transversemercator'):
proj = ccrs.TransverseMercator(
central_longitude=central_longitude,
central_latitude=central_latitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
scale_factor=1.0, ##########
approx=approx)
elif (proj_name == 'utm'):
proj = ccrs.UTM(zone,
southern_hemisphere=southern_hemisphere,
globe=globe)
elif (proj_name == 'interruptedgoodehomolosine'):
proj = ccrs.InterruptedGoodeHomolosine(
central_longitude=central_longitude, globe=globe)
elif (proj_name == 'rotatedpole'):
proj = ccrs.RotatedPole(
pole_longitude=pole_longitude,
pole_latitude=pole_latitude,
globe=globe,
central_rotated_longitude=central_rotated_longitude)
elif (proj_name == 'osgb'):
proj = ccrs.OSGB(approx=approx)
elif (proj_name == 'europp'):
proj = ccrs.EuroPP
elif (proj_name == 'geostationary'):
proj = ccrs.Geostationary(central_longitude=central_longitude,
satellite_height=satellite_height,
false_easting=false_easting,
false_northing=false_northing,
globe=globe,
sweep_axis=sweep_axis)
elif (proj_name == 'nearsideperspective'):
proj = ccrs.NearsidePerspective(central_longitude=central_longitude,
central_latitude=central_latitude,
satellite_height=satellite_height,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckerti'):
proj = ccrs.EckertI(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertii'):
proj = ccrs.EckertII(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertiii'):
proj = ccrs.EckertIII(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertiv'):
proj = ccrs.EckertIV(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertv'):
proj = ccrs.EckertV(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'eckertvi'):
proj = ccrs.EckertVI(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'equalearth'):
proj = ccrs.EqualEarth(central_longitude=central_longitude,
false_easting=false_easting,
false_northing=false_northing,
globe=globe)
elif (proj_name == 'gnomonic'):
proj = ccrs.Gnomonic(central_latitude=central_latitude,
central_longitude=central_longitude,
globe=globe)
elif (proj_name == 'lambertazimuthalequalarea'):
proj = ccrs.LambertAzimuthalEqualArea(
central_longitude=central_longitude,
central_latitude=central_latitude,
globe=globe,
false_easting=false_easting,
false_northing=false_northing)
elif (proj_name == 'northpolarstereo'):
proj = ccrs.NorthPolarStereo(central_longitude=central_longitude,
true_scale_latitude=true_scale_latitude,
globe=globe)
elif (proj_name == 'osni'):
proj = ccrs.OSNI(approx=approx)
elif (proj_name == 'southpolarstereo'):
proj = ccrs.SouthPolarStereo(central_longitude=central_longitude,
true_scale_latitude=true_scale_latitude,
globe=globe)
else:
# This is same as "Geographic coordinates"
proj = ccrs.PlateCarree(central_longitude=central_longitude,
globe=globe)
return proj
