def test_offset(self):
crs = ccrs.Sinusoidal()
crs_offset = ccrs.Sinusoidal(false_easting=1234, false_northing=-4321)
other_args = {'ellps=WGS84', 'lon_0=0.0', 'x_0=1234', 'y_0=-4321'}
check_proj_params('sinu', crs_offset, other_args)
assert tuple(np.array(crs.x_limits) + 1234) == crs_offset.x_limits
assert tuple(np.array(crs.y_limits) - 4321) == crs_offset.y_limits
def test_offset(self):
crs = ccrs.Sinusoidal()
crs_offset = ccrs.Sinusoidal(false_easting=1234, false_northing=-4321)
expected = ('+ellps=WGS84 +proj=sinu +lon_0=0.0 +x_0=1234 '
'+y_0=-4321 +no_defs')
assert_equal(crs_offset.proj4_init, expected)
assert_equal(tuple(np.array(crs.x_limits) + 1234), crs_offset.x_limits)
assert_equal(tuple(np.array(crs.y_limits) - 4321), crs_offset.y_limits)
def test_pretty_plot():
image = os.path.join(root_path.test_root, '00_testdata', 'plot',
'ESACCI-SOILMOISTURE-L3S-SSMV-COMBINED-20100701000000-fv04.5.nc')
ds = Dataset(image)
dat = ds.variables['sm'][:]
dat = dat.filled(np.nan).flatten()
_, resampled_lons, resampled_lats, _ = SMECV_Grid_v052(None).get_grid_points()
index =pd.MultiIndex.from_arrays(np.array([resampled_lats, resampled_lons]),
names=['lats', 'lons'])
df = pd.DataFrame(index=index, data={'sm': dat}).dropna()
f, imax, im = cp_map(df, 'sm', resxy=(0.25,0.25), cbrange=(0,50.), veg_mask=True,
cmap=cm_sm, projection=ccrs.Sinusoidal(),
title='Overloaded Plot with too much Information',
ocean=True, land='grey', gridspace=(60,20), states=True,
borders=True, llc=(-179.9999, -90.), urc=(179.9999, 90),
cb_label='ESA CCI SM [$m^3/m^3$]', cb_labelsize=7, scale_factor=100,
grid_label_loc='0111', coastline_size='110m', cb_extend='both',
cb_ext_label_min='DRY', cb_ext_label_max='WET', cb_loc='right')
out_dir = tempfile.mkdtemp()
try:
filename = 'pretty_plot.png'
f.savefig(os.path.join(out_dir, 'pretty_plot.png'), dpi=200)
assert os.path.isfile(os.path.join(out_dir, filename))
finally:
shutil.rmtree(out_dir)
def __init__(self, src_cube, tgt_grid_cube, method, projection=None):
"""
Create a regridder for conversions between the source
and target grids.
Args:
* src_cube:
The :class:`~iris.cube.Cube` providing the source points.
* tgt_grid_cube:
The :class:`~iris.cube.Cube` providing the target grid.
* method:
Either 'linear' or 'nearest'.
* projection:
The projection in which the interpolation is performed. If None, a
PlateCarree projection is used. Defaults to None.
"""
# Validity checks.
if not isinstance(src_cube, iris.cube.Cube):
raise TypeError("'src_cube' must be a Cube")
if not isinstance(tgt_grid_cube, iris.cube.Cube):
raise TypeError("'tgt_grid_cube' must be a Cube")
# Snapshot the state of the target cube to ensure that the regridder
# is impervious to external changes to the original source cubes.
self._tgt_grid = snapshot_grid(tgt_grid_cube)
# Check the target grid units.
for coord in self._tgt_grid:
self._check_units(coord)
# Whether to use linear or nearest-neighbour interpolation.
if method not in ('linear', 'nearest'):
msg = 'Regridding method {!r} not supported.'.format(method)
raise ValueError(msg)
self._method = method
src_x_coord, src_y_coord = get_xy_coords(src_cube)
if src_x_coord.coord_system != src_y_coord.coord_system:
raise ValueError("'src_cube' lateral geographic coordinates have "
"differing coordinate sytems.")
if src_x_coord.coord_system is None:
raise ValueError("'src_cube' lateral geographic coordinates have "
"no coordinate sytem.")
tgt_x_coord, tgt_y_coord = get_xy_dim_coords(tgt_grid_cube)
if tgt_x_coord.coord_system != tgt_y_coord.coord_system:
raise ValueError("'tgt_grid_cube' lateral geographic coordinates "
"have differing coordinate sytems.")
if tgt_x_coord.coord_system is None:
raise ValueError("'tgt_grid_cube' lateral geographic coordinates "
"have no coordinate sytem.")
if projection is None:
globe = src_x_coord.coord_system.as_cartopy_globe()
projection = ccrs.Sinusoidal(globe=globe)
self._projection = projection
def test_nearest_sinusoidal(self):
crs = ccrs.Sinusoidal()
res = self.src.regrid(self.global_grid,
ProjectedUnstructuredNearest(crs))
self.assertArrayShapeStats(res, (1, 6, 73, 96),
315.891358296,
11.000639227,
rtol=1e-8)
self.assertArrayShapeStats(res[:, 0], (1, 73, 96), 299.99993826,
3.9223839688e-5)
def test_eccentric_globe(self):
globe = ccrs.Globe(semimajor_axis=1000, semiminor_axis=500,
ellipse=None)
crs = ccrs.Sinusoidal(globe=globe)
other_args = {'a=1000', 'b=500', 'lon_0=0.0', 'x_0=0.0', 'y_0=0.0'}
check_proj_params('sinu', crs, other_args)
assert_almost_equal(np.array(crs.x_limits),
[-3141.59, 3141.59], decimal=2)
assert_almost_equal(np.array(crs.y_limits),
[-1216.60, 1216.60], decimal=2)
def test_default(self):
crs = ccrs.Sinusoidal()
other_args = {'ellps=WGS84', 'lon_0=0.0', 'x_0=0.0', 'y_0=0.0'}
check_proj_params('sinu', crs, other_args)
assert_almost_equal(np.array(crs.x_limits),
[-20037508.3428, 20037508.3428],
decimal=4)
assert_almost_equal(np.array(crs.y_limits),
[-10001965.7293, 10001965.7293],
decimal=4)
def test_central_longitude(self, lon):
crs = ccrs.Sinusoidal(central_longitude=lon)
other_args = {'ellps=WGS84', f'lon_0={lon}', 'x_0=0.0', 'y_0=0.0'}
check_proj_params('sinu', crs, other_args)
assert_almost_equal(np.array(crs.x_limits),
[-20037508.3428, 20037508.3428],
decimal=4)
assert_almost_equal(np.array(crs.y_limits),
[-10001965.7293, 10001965.7293],
decimal=4)
def __create_plot_objects(self):
"""
Create plot objects
"""
years_fmt = mdates.DateFormatter('%Y')
# Get projection from first data variable
for key in self.ts.data.data_vars:
proj4_string = getattr(self.ts.data, key).crs
break
# If projection is Sinusoidal
srs = get_projection(proj4_string)
if srs.GetAttrValue('PROJECTION') == 'Sinusoidal':
globe=ccrs.Globe(ellipse=None,
semimajor_axis=6371007.181,
semiminor_axis=6371007.181)
self.projection = ccrs.Sinusoidal(globe=globe)
else:
globe = ccrs.Globe(ellipse='WGS84')
self.projection = ccrs.Mollweide(globe=globe)
# Figure
self.fig = plt.figure(figsize=(11.0, 6.0))
# subplot2grid((rows,cols), (row,col)
# Left, right and climatology plots
self.left_p = plt.subplot2grid((4, 4), (0, 0), rowspan=2,
projection=self.projection)
self.right_p = plt.subplot2grid((4, 4), (0, 1), rowspan=2,
sharex=self.left_p, sharey=self.left_p,
projection=self.projection)
if self.projection is not None:
for _axis in [self.left_p, self.right_p]:
_axis.coastlines(resolution='10m', color='white')
_axis.add_feature(cfeature.BORDERS, edgecolor='white')
_axis.gridlines()
self.climatology = plt.subplot2grid((4, 4), (2, 0),
rowspan=2, colspan=2)
# Time series plot
self.observed = plt.subplot2grid((4, 4), (0, 2), colspan=2)
self.observed.xaxis.set_major_formatter(years_fmt)
self.trend_p = plt.subplot2grid((4, 4), (1, 2), colspan=2,
sharex=self.observed)
self.seasonal_p = plt.subplot2grid((4, 4), (2, 2), colspan=2,
sharex=self.observed)
self.resid_p = plt.subplot2grid((4, 4), (3, 2), colspan=2,
sharex=self.observed)
def test_default(self):
crs = ccrs.Sinusoidal()
expected = ('+ellps=WGS84 +proj=sinu +lon_0=0.0 '
'+x_0=0.0 +y_0=0.0 +no_defs')
assert_equal(crs.proj4_init, expected)
assert_almost_equal(np.array(crs.x_limits),
[-20037508.3428, 20037508.3428],
decimal=4)
assert_almost_equal(np.array(crs.y_limits),
[-10001965.7293, 10001965.7293],
decimal=4)
def test_eccentric_globe(self):
globe = ccrs.Globe(semimajor_axis=1000, semiminor_axis=500,
ellipse=None)
crs = ccrs.Sinusoidal(globe=globe)
expected = ('+a=1000 +b=500 +proj=sinu +lon_0=0.0 +x_0=0.0 '
'+y_0=0.0 +no_defs')
assert_equal(crs.proj4_init, expected)
assert_almost_equal(np.array(crs.x_limits),
[-3141.59, 3141.59], decimal=2)
assert_almost_equal(np.array(crs.y_limits),
[-1216.60, 1216.60], decimal=2)
def plot(family_locations,
resources,
maximum=3650000000.0,
hexes=[],
color_schema={}) -> None:
plt.gcf().set_size_inches(30, 30)
ax = plt.axes(projection=ccrs.Sinusoidal(-98))
if resources is not None:
raise NotImplementedError
ax.coastlines("50m")
ax.set_extent((hexgrid.AMERICAS.w, hexgrid.AMERICAS.e, hexgrid.AMERICAS.s,
hexgrid.AMERICAS.n))
G, xyz = connect_agents(family_locations)
new_color_schema = {}
# for community in G.community_label_propagation():
# for community in G.community_infomap():
for community in G.community_fastgreedy().as_clustering():
pos = numpy.array([(xyz[n][0], xyz[n][1]) for n in community])
s = [xyz[n][2] for n in community]
mean = numpy.mean(pos, axis=0)
closest = numpy.inf
for location, popsize in color_schema:
dist = numpy.linalg.norm(mean - location) + abs(
numpy.log(
(popsize + 1) / (len(community) + 1))) / numpy.log(1.04)
if dist > 20:
continue
if dist < closest:
closest = dist
reference = location, popsize
if numpy.isfinite(closest):
color = color_schema.pop(reference)
else:
color = numpy.random.random(3)
new_color_schema[tuple(mean), len(community)] = color
ax.scatter(*pos.T,
s=s,
c=[color],
alpha=0.2,
edgecolors=None,
transform=ccrs.Geodetic())
for key in list(color_schema):
color_schema.pop(key)
color_schema.update(new_color_schema)
def on_pbOverlay_click(self):
"""
EXPERIMENTAL
Overlay a specific geometry on maps
"""
fname = open_file_dialog(dialog_type = 'open_specific',
data_format = 'Shapefile',
extension = 'shp')
# If there is no selection
if fname == '':
return None
# If file does not exists
if os.path.exists(fname) is False:
return None
# Open file
spatial_reference = self.get_shapefile_spatial_reference(fname)
# Get projection from first data variable
for key in self.ts.data.data_vars:
proj4_string = getattr(self.ts.data, key).crs
break
# If projection is Sinusoidal
srs = get_projection(proj4_string)
if srs.GetAttrValue('PROJECTION') == 'Sinusoidal':
# Get ellipsoid/datum parameters
globe=ccrs.Globe(ellipse=None,
semimajor_axis=spatial_reference.GetSemiMajor(),
semiminor_axis=spatial_reference.GetSemiMinor())
self.shapefile_projection = ccrs.Sinusoidal(globe=globe)
#ccrs.CRS(spatial_reference.ExportToProj4())
else:
globe = ccrs.Globe(ellipse='WGS84')
self.shapefile_projection = ccrs.Mollweide(globe=globe)
try:
shape_feature = ShapelyFeature(cReader(fname).geometries(),
self.shapefile_projection, facecolor='none')
for _axis in [self.left_p, self.right_p]:
_axis.add_feature(shape_feature,
edgecolor='gray')
except:
return None
self.fig.canvas.draw()
self.fig.canvas.flush_events()
def proj_grid(lon_0, lat_0, dx, nx, ny, bearing, dy=None):
"""
Define a regular grid over geographical space.
Parameters
----------
lon_0, lat_0: float
PlateCarree coordinates of mean grid position.
dx, dy: float
Horizontal and vertical resolutions in meters.
nx, ny: int
Horizontal and vertical number of grid points.
bearing: float
Compass orientation of horizontal dimension.
Returns
-------
2D array
Horizontal and vertical grid coordinates.
cartopy.crs
Coordinate reference system in which grid is defined.
"""
def _crs2crs(x, y, target, origin=ccrs.PlateCarree()):
"""
Using the version in convert results in a circular import.
"""
x, y = np.array([x, x]), np.array([y, y])
transformed = target.transform_points(origin, x, y)
x_dest, y_dest = transformed[0, 0], transformed[0, 1]
return x_dest, y_dest
# Default to equal spacing in both directions
dy = dy or dx
# Get equal area projection
pj_sine = ccrs.Sinusoidal(central_longitude=lon_0)
x_g = np.arange(0, (nx + 1) * dx, dx)
y_g = np.arange(0, (ny + 1) * dy, dy)
XG, YG = np.meshgrid(x_g, y_g)
# Set to required center
x_0, y_0 = _crs2crs(lon_0, lat_0, pj_sine)
XG = XG - XG.mean() + x_0
YG = YG - YG.mean() + y_0
# Rotate
XG, YG = rotate_frame(XG, YG, (90 - bearing) * np.pi / 180, inplace=True)
return XG, YG, pj_sine
def show_proj(latitudes, longitudes, angle, extent, proj, label=''):
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.collections as mplcollections
from matplotlib.patches import Circle
import cartopy.crs as ccrs
from math import degrees as to_deg
# Ustawianie kolorów
colors = np.linspace(0, 1, num=5)
if extent == None:
extent = [0, 0, 0, 0]
# Ustawianie rzutowania
if proj == 'orto':
bmap = ccrs.Orthographic(
central_longitude=((extent[0] + extent[1]) / 2),
central_latitude=((extent[2] + extent[3]) / 2))
if proj == 'albers':
bmap = ccrs.AlbersEqualArea(central_longitude=0)
if proj == 'sinus':
bmap = ccrs.Sinusoidal(central_longitude=((extent[0] + extent[1]) / 2))
if proj == 'merc':
bmap = ccrs.Mercator(central_longitude=((extent[0] + extent[1]) / 2))
if proj == 'plate':
bmap = ccrs.PlateCarree(central_longitude=((extent[0] + extent[1]) /
2))
ax = plt.axes(projection=bmap)
ax.set_global()
ax.coastlines()
ax.gridlines()
if not extent == [0, 0, 0, 0]:
ax.set_extent(extent)
# Ładowanie kół opisujących maksymalną widoczność
patches = []
for i in range(len(latitudes)):
patches.append(
Circle((latitudes[i], longitudes[i]), radius=to_deg(angle[i])))
collection = mplcollections.PatchCollection(patches,
transform=ccrs.PlateCarree())
# Rysowanie
collection.set_array(colors)
ax.add_collection(collection)
ax.set_title(label)
plt.savefig('CircleTest.png', dpi=100)
plt.show()
return ()
def on_pbOverlay_click(self):
"""
EXPERIMENTAL
Overlay a specific geometry on maps
"""
fname = open_file_dialog(dialog_type = 'open_specific',
data_format = 'Shapefile',
extension = 'shp')
# If there is no selection
if fname == '':
return None
# If file does not exists
if os.path.exists(fname) is False:
return None
# Open file
spatial_reference = self.get_shapefile_spatial_reference(fname)
# Get ellipsoid/datum parameters
globe=ccrs.Globe(ellipse=None,
semimajor_axis=spatial_reference.GetSemiMajor(),
semiminor_axis=spatial_reference.GetSemiMinor())
self.shapefile_projection = ccrs.Sinusoidal(globe=globe)
#ccrs.CRS(spatial_reference.ExportToProj4())
from IPython import embed ; ipshell = embed()
try:
shape_feature = ShapelyFeature(cReader(fname).geometries(),
self.shapefile_projection, facecolor='none')
for _axis in [self.ax]:
_axis.add_feature(shape_feature,
edgecolor='gray')
except:
return None
self.fig.canvas.draw()
self.fig.canvas.flush_events()
def __create_plot_objects(self):
"""
Create plot objects
"""
# Get projection from first data variable
for key in self.qa_analytics.ts.data.data_vars:
proj4_string = getattr(self.qa_analytics.ts.data, key).crs
break
# If projection is Sinusoidal
srs = get_projection(proj4_string)
if srs.GetAttrValue('PROJECTION') == 'Sinusoidal':
globe=ccrs.Globe(ellipse=None,
semimajor_axis=6371007.181,
semiminor_axis=6371007.181)
self.projection = ccrs.Sinusoidal(globe=globe)
else:
globe = ccrs.Globe(ellipse='WGS84')
self.projection = ccrs.Mollweide(globe=globe)
# Figure
self.fig = plt.figure(figsize=(8.0, 7.0))
# Left plot
self.left_p = plt.subplot2grid((2, 2), (0, 0), colspan=1,
projection=self.projection)
# Right plot
self.right_p = plt.subplot2grid((2, 2), (0, 1), colspan=1,
sharex=self.left_p, sharey=self.left_p,
projection=self.projection)
if self.projection is not None:
for _axis in [self.left_p, self.right_p]:
_axis.coastlines(resolution='10m', color='white')
_axis.add_feature(cfeature.BORDERS, edgecolor='white')
_axis.gridlines()
# Time series plot
self.ts_p = plt.subplot2grid((2, 2), (1, 0), colspan=2)
import matplotlib.pyplot as plt import cartopy.crs as ccrs plt.figure(figsize=(6.0101, 3)) ax = plt.axes(projection=ccrs.Sinusoidal()) ax.coastlines(resolution='110m') ax.gridlines()
def plot_map(ds: xr.Dataset,
var: VarName.TYPE = None,
indexers: DictLike.TYPE = None,
time: TimeLike.TYPE = None,
region: PolygonLike.TYPE = None,
projection: str = 'PlateCarree',
central_lon: float = 0.0,
title: str = None,
properties: DictLike.TYPE = None,
file: str = None) -> Figure:
"""
Create a geographic map plot for the variable given by dataset *ds* and variable name *var*.
Plots the given variable from the given dataset on a map with coastal lines.
In case no variable name is given, the first encountered variable in the
dataset is plotted. In case no *time* is given, the first time slice
is taken. It is also possible to set extents of the plot. If no extents
are given, a global plot is created.
The plot can either be shown using pyplot functionality, or saved,
if a path is given. The following file formats for saving the plot
are supported: eps, jpeg, jpg, pdf, pgf, png, ps, raw, rgba, svg,
svgz, tif, tiff
:param ds: the dataset containing the variable to plot
:param var: the variable's name
:param indexers: Optional indexers into data array of *var*. The *indexers* is a dictionary
or a comma-separated string of key-value pairs that maps the variable's dimension names
to constant labels. e.g. "layer=4".
:param time: time slice index to plot, can be a string "YYYY-MM-DD" or an integer number
:param region: Region to plot
:param projection: name of a global projection, see http://scitools.org.uk/cartopy/docs/v0.15/crs/projections.html
:param central_lon: central longitude of the projection in degrees
:param title: an optional title
:param properties: optional plot properties for Python matplotlib,
e.g. "bins=512, range=(-1.5, +1.5)"
For full reference refer to
https://matplotlib.org/api/lines_api.html and
https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.contourf.html
:param file: path to a file in which to save the plot
:return: a matplotlib figure object or None if in IPython mode
"""
if not isinstance(ds, xr.Dataset):
raise NotImplementedError(
'Only gridded datasets are currently supported')
var_name = None
if not var:
for key in ds.data_vars.keys():
var_name = key
break
else:
var_name = VarName.convert(var)
var = ds[var_name]
time = TimeLike.convert(time)
indexers = DictLike.convert(indexers) or {}
properties = DictLike.convert(properties) or {}
extents = None
region = PolygonLike.convert(region)
if region:
lon_min, lat_min, lon_max, lat_max = region.bounds
if not _check_bounding_box(lat_min, lat_max, lon_min, lon_max):
raise ValueError(
'Provided plot extents do not form a valid bounding box '
'within [-180.0,+180.0,-90.0,+90.0]')
extents = [lon_min, lon_max, lat_min, lat_max]
# See http://scitools.org.uk/cartopy/docs/v0.15/crs/projections.html#
if projection == 'PlateCarree':
proj = ccrs.PlateCarree(central_longitude=central_lon)
elif projection == 'LambertCylindrical':
proj = ccrs.LambertCylindrical(central_longitude=central_lon)
elif projection == 'Mercator':
proj = ccrs.Mercator(central_longitude=central_lon)
elif projection == 'Miller':
proj = ccrs.Miller(central_longitude=central_lon)
elif projection == 'Mollweide':
proj = ccrs.Mollweide(central_longitude=central_lon)
elif projection == 'Orthographic':
proj = ccrs.Orthographic(central_longitude=central_lon)
elif projection == 'Robinson':
proj = ccrs.Robinson(central_longitude=central_lon)
elif projection == 'Sinusoidal':
proj = ccrs.Sinusoidal(central_longitude=central_lon)
elif projection == 'NorthPolarStereo':
proj = ccrs.NorthPolarStereo(central_longitude=central_lon)
elif projection == 'SouthPolarStereo':
proj = ccrs.SouthPolarStereo(central_longitude=central_lon)
else:
raise ValueError('illegal projection: "%s"' % projection)
figure = plt.figure(figsize=(8, 4))
ax = plt.axes(projection=proj)
if extents:
ax.set_extent(extents)
else:
ax.set_global()
ax.coastlines()
var_data = _get_var_data(var,
indexers,
time=time,
remaining_dims=('lon', 'lat'))
var_data.plot.contourf(ax=ax, transform=proj, **properties)
if title:
ax.set_title(title)
figure.tight_layout()
if file:
figure.savefig(file)
return figure if not in_notebook() else None
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
def _plot(self, qa_analytics, cmap='viridis', dpi=72):
"""
From the TATSSI QA Analytics object plots:
- Percentage of data available
- Maximum gap length
"""
uic.loadUi('plot.ui', self)
# Get projection from first data variable
for key in qa_analytics.ts.data.data_vars:
proj4_string = getattr(qa_analytics.ts.data, key).crs
break
# If projection is Sinusoidal
srs = get_projection(proj4_string)
if srs.GetAttrValue('PROJECTION') == 'Sinusoidal':
globe=ccrs.Globe(ellipse=None,
semimajor_axis=6371007.181,
semiminor_axis=6371007.181)
proj = ccrs.Sinusoidal(globe=globe)
else:
globe = ccrs.Globe(ellipse='WGS84')
proj = ccrs.Mollweide(globe=globe)
fig, (ax, bx) = plt.subplots(1, 2, figsize=(16, 9.6),
#sharex=True, sharey=True, tight_layout=True, dpi=dpi,
sharex=True, sharey=True, dpi=dpi,
subplot_kw=dict(projection=proj))
if proj is not None:
for _axis in [ax, bx]:
_axis.coastlines(resolution='10m', color='white')
_axis.add_feature(cfeature.BORDERS, edgecolor='white')
_axis.gridlines()
qa_analytics.pct_data_available.plot.imshow(
ax=ax, cmap=cmap,
cbar_kwargs={'orientation':'horizontal',
'pad' : 0.005},
transform=proj
)
ax.set_frame_on(False)
ax.axis('off')
ax.set_aspect('equal')
ax.title.set_text('% of data available')
qa_analytics.max_gap_length.plot.imshow(
ax=bx, cmap=cmap,
cbar_kwargs={'orientation':'horizontal',
'pad' : 0.005},
transform=proj
)
bx.set_frame_on(False)
bx.axis('off')
bx.set_aspect('equal')
bx.title.set_text('Max gap-length')
# Set plot on the plot widget
self.plotWidget = FigureCanvas(fig)
lay = QtWidgets.QVBoxLayout(self.content_plot)
lay.setContentsMargins(0, 0, 0, 0)
lay.addWidget(self.plotWidget)
# Add toolbar
font = QFont()
font.setPointSize(12)
toolbar = NavigationToolbar(self.plotWidget, self)
toolbar.setFont(font)
self.addToolBar(QtCore.Qt.BottomToolBarArea, toolbar)
# Needed in order to use a tight layout with Cartopy axes
fig.canvas.draw()
plt.tight_layout()
def set_of_photos(hrit_files,
central_lat,
central_lon,
elevation,
time,
dpi,
photo_path,
all_lines=False,
load_photo=['VIS006']):
"""Return path of photo
Parameters
----------
parameter_name : parameter_type
Quick description of it.
Returns
-------
photos: array
Array of saved on disc files.
"""
# Loading decompressed previously photos
from satpy import Scene
import numpy as np
# from glob import glob
import matplotlib.pyplot as plt
from satpy import find_files_and_readers
from datetime import datetime
import cartopy.crs as ccrs
import matplotlib as mpl
mpl.rcParams['figure.dpi'] = dpi
# load_photo = 'VIS006'
first = 0
last = len(time) - 1
# print(len(time),last)
yearF, monthF, dayF, hourF, minuteF, secondF = time[first].tt_calendar()
yearL, monthL, dayL, hourL, minuteL, secondL = time[last].tt_calendar()
# IT IS NOT WORKING FIND SOLUTION - Adding a minute in case there is only one point on map
if len(time) == 1:
time[last].tt = time[last].tt + 1 / 3600
yearL, monthL, dayL, hourL, minuteL, secondL = time[last].tt_calendar()
# print("udalosie")
# print(yearF, monthF, dayF, hourF, minuteF, secondF )
# print(yearL, monthL, dayL, hourL, minuteL, secondL)
# time[0].tt_calendar()[0]
files = find_files_and_readers(base_dir=hrit_files,
start_time=datetime(yearF, monthF, dayF,
hourF, minuteF),
end_time=datetime(yearL, monthL, dayL,
hourL, minuteL),
reader='seviri_l1b_hrit')
scn = Scene(filenames=files)
load_photo = scn.available_dataset_names()
# HRV does not work properly
load_photo.remove('HRV')
# print(load_photo)
# print(scn.available_dataset_names())
div = 30
name_img = []
for photo_type in load_photo:
# print(photo_type)
scn.load([photo_type])
# print(scn)
for i in range(len(time)):
new_scn = scn
# print(new_scn)
crs = new_scn[photo_type].attrs['area'].to_cartopy_crs()
y, x = polygon_surrounding_sat(central_lat[i], central_lon[i],
elevation[i], div)
extent = calculate_extent(x, y)
ax = plt.axes(
projection=ccrs.Sinusoidal(central_lon[i], central_lat[i]))
ax.set_extent(extent)
if (all_lines):
ax.gridlines()
ax.coastlines(resolution='50m', color='red')
ax.coastlines()
# ax.gridlines()
# ax.set_global()
plt.imshow(new_scn[photo_type],
transform=crs,
extent=crs.bounds,
origin='upper',
cmap='gray')
# cbar = plt.colorbar()
# cbar.set_label("Kelvin")
# plt.imsave('imsave.png', im, cmap='gray')
name = photo_path + photo_type + "_" + time[i].utc_iso() + '.png'
plt.savefig(name, dpi=dpi)
name_img = np.append(name_img, name)
return (name_img)
def photo_of_area(hrit_files,
central_lat,
central_lon,
elevation,
time,
dpi,
photo_path,
load_photo='VIS006',
all_lines=True):
"""Return path of photo
Parameters
----------
parameter_name : parameter_type
Quick description of it.
Returns
-------
photos: array
Array of saved on disc files.
"""
# Loading decompressed previously photos
from satpy import Scene
# from glob import glob
import matplotlib.pyplot as plt
from satpy import find_files_and_readers
from datetime import datetime
import cartopy.crs as ccrs
import matplotlib as mpl
mpl.rcParams['figure.dpi'] = dpi
# load_photo = 'VIS006'
first = 0
last = len(time) - 1
# print(len(time),last)
yearF, monthF, dayF, hourF, minuteF, secondF = time[first].tt_calendar()
yearL, monthL, dayL, hourL, minuteL, secondL = time[last].tt_calendar()
# IT IS NOT WORKING FIND SOLUTION - Adding a minute in case there is only one point on map
if (len(time) == 1):
time[last].tt = time[last].tt + 1 / 3600
yearL, monthL, dayL, hourL, minuteL, secondL = time[last].tt_calendar()
# print("udalosie")
# print(yearF, monthF, dayF, hourF, minuteF, secondF )
# print(yearL, monthL, dayL, hourL, minuteL, secondL)
time[0].tt_calendar()[0]
files = find_files_and_readers(base_dir=hrit_files,
start_time=datetime(yearF, monthF, dayF,
hourF, minuteF),
end_time=datetime(yearL, monthL, dayL,
hourL, minuteL),
reader='seviri_l1b_hrit')
scn = Scene(filenames=files)
scn.load([load_photo])
new_scn = scn
crs = new_scn[load_photo].attrs['area'].to_cartopy_crs()
div = 30
y, x = polygon_surrounding_sat(central_lat, central_lon, elevation, div)
extent = calculate_extent(x, y)
ax = plt.axes(projection=ccrs.Sinusoidal(central_lon, central_lat))
ax.set_extent(extent)
if (all_lines):
ax.gridlines()
ax.coastlines(resolution='50m', color='red')
ax.coastlines()
# ax.gridlines()
# ax.set_global()
plt.imshow(new_scn[load_photo],
transform=crs,
extent=crs.bounds,
origin='upper',
cmap='gray')
# cbar = plt.colorbar()
# cbar.set_label("Kelvin")
# plt.imsave('imsave.png', im, cmap='gray')
name_img = photo_path + load_photo + "_" + datetime(
yearF, monthF, dayF, hourF, minuteF).__str__() + '.png'
plt.savefig(name_img, dpi=dpi)
# print(name_img)
return name_img
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
def show_overall(hrit_files,
central_lat,
central_lon,
elevation,
time,
dpi,
photo_path,
all_lines=False,
pro='PlateCarree',
load_photo=['VIS006'],
save=False):
"""Return path of photo
Parameters
----------
pro : string
PlateCarree
Sinusoidal
Returns
-------
photos: array
Array of saved on disc files.
"""
from satpy.scene import Scene
from satpy import find_files_and_readers
from datetime import datetime
import cartopy.crs as ccrs
import cartopy.feature as cfeature
import numpy as np
# %matplotlib inline
import matplotlib.pyplot as plt
### START - CALCULATES OVERALL EXTENT ###
div = 30
x, y = [], []
for i in range(len(central_lat)):
y_temp, x_temp = polygon_surrounding_sat(central_lat[i],
central_lon[i], elevation[i],
div)
x = np.append(x, x_temp)
y = np.append(y, y_temp)
extent = calculate_extent(x, y)
### END - CALCULATES OVERALL EXTENT ###
first = 0
last = len(time) - 1
yearF, monthF, dayF, hourF, minuteF, secondF = time[first].tt_calendar()
yearL, monthL, dayL, hourL, minuteL, secondL = time[last].tt_calendar()
if len(time) == 1:
time[last].tt = time[last].tt + 1 / 3600
yearL, monthL, dayL, hourL, minuteL, secondL = time[last].tt_calendar()
# print(yearF, monthF, dayF, hourF, minuteF, secondF )
# print(yearL, monthL, dayL, hourL, minuteL, secondL)
# time[0].tt_calendar()[0]
files = find_files_and_readers(base_dir=hrit_files,
start_time=datetime(yearF, monthF, dayF,
hourF, minuteF),
end_time=datetime(yearL, monthL, dayL,
hourL, minuteL),
reader='seviri_l1b_hrit')
scn = Scene(filenames=files)
scn.load(load_photo)
new_scn = scn
crs = new_scn[load_photo[0]].attrs['area'].to_cartopy_crs()
# ax = plt.axes(projection=crs)
central_lon, central_lat = (extent[0] + extent[1]) / 2, (extent[2] +
extent[3]) / 2
if pro == 'PlateCarree':
ax = plt.axes(projection=ccrs.PlateCarree())
pro_name = '_PlateCarree_'
ax.set_global()
if pro == 'Sinusoidal':
ax = plt.axes(projection=ccrs.Sinusoidal(central_lon, central_lat))
ax.set_extent(extent)
pro_name = '_Sinusoidal_'
if all_lines:
ax.coastlines(color='red')
ax.gridlines(color='red')
ax.add_feature(cfeature.BORDERS, color='red')
pro_name = pro_name + 'lines_'
plt.imshow(new_scn[load_photo[0]],
transform=crs,
extent=crs.bounds,
origin='upper',
cmap='gray')
if save:
if isinstance(load_photo[0], float):
photo_type = str(load_photo[0])
else:
photo_type = load_photo[0]
name = photo_path + photo_type + pro_name + '_{date:%Y-%m-%d_%H_%M_%S}.png'.format(
date=scn.start_time)
plt.savefig(name, dpi=dpi)
if not save:
plt.show()
return ()
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)
def animate_map(ds: xr.Dataset,
var: VarName.TYPE = None,
animate_dim: str = 'time',
interval: int = 200,
true_range: bool = False,
indexers: DictLike.TYPE = None,
region: PolygonLike.TYPE = None,
projection: str = 'PlateCarree',
central_lon: float = 0.0,
title: str = None,
contour_plot: bool = False,
cmap_params: DictLike.TYPE = None,
plot_properties: DictLike.TYPE = None,
file: str = None,
monitor: Monitor = Monitor.NONE) -> HTML:
"""
Create a geographic map animation for the variable given by dataset *ds* and variable name *var*.
Creates an animation of the given variable from the given dataset on a map with coastal lines.
In case no variable name is given, the first encountered variable in the
dataset is animated.
It is also possible to set extents of the animation. If no extents
are given, a global animation is created.
The following file formats for saving the animation are supported: html
:param ds: the dataset containing the variable to animate
:param var: the variable's name
:param animate_dim: Dimension to animate, if none given defaults to time.
:param interval: Delay between frames in milliseconds. Defaults to 200.
:param true_range: If True, calculates colormap and colorbar configuration parameters from the
whole dataset. Can potentially take a lot of time. Defaults to False, in which case the colormap
is calculated from the first frame.
:param indexers: Optional indexers into data array of *var*. The *indexers* is a dictionary
or a comma-separated string of key-value pairs that maps the variable's dimension names
to constant labels. e.g. "layer=4".
:param region: Region to animate
:param projection: name of a global projection, see http://scitools.org.uk/cartopy/docs/v0.15/crs/projections.html
:param central_lon: central longitude of the projection in degrees
:param title: an optional title
:param contour_plot: If true plot a filled contour plot of data, otherwise plots a pixelated colormesh
:param cmap_params: optional additional colormap configuration parameters,
e.g. "vmax=300, cmap='magma'"
For full reference refer to
http://xarray.pydata.org/en/stable/generated/xarray.plot.contourf.html
:param plot_properties: optional plot properties for Python matplotlib,
e.g. "bins=512, range=(-1.5, +1.5)"
For full reference refer to
https://matplotlib.org/api/lines_api.html and
https://matplotlib.org/api/_as_gen/matplotlib.axes.Axes.contourf.html
:param file: path to a file in which to save the animation
:param monitor: A progress monitor.
:return: An animation in HTML format
"""
if not isinstance(ds, xr.Dataset):
raise NotImplementedError('Only gridded datasets are currently supported')
var_name = None
if not var:
for key in ds.data_vars.keys():
var_name = key
break
else:
var_name = VarName.convert(var)
try:
var = ds[var_name]
except KeyError:
raise ValidationError('Provided variable name "{}" does not exist in the given dataset'.format(var_name))
indexers = DictLike.convert(indexers) or {}
properties = DictLike.convert(plot_properties) or {}
cmap_params = DictLike.convert(cmap_params) or {}
extents = None
bounds = handle_plot_polygon(region)
if bounds:
lon_min, lat_min, lon_max, lat_max = bounds
extents = [lon_min, lon_max, lat_min, lat_max]
if len(ds.lat) < 2 or len(ds.lon) < 2:
# Matplotlib can not plot datasets with less than these dimensions with
# contourf and pcolormesh methods
raise ValidationError('The minimum dataset spatial dimensions to create a map'
' plot are (2,2)')
# See http://scitools.org.uk/cartopy/docs/v0.15/crs/projections.html#
if projection == 'PlateCarree':
proj = ccrs.PlateCarree(central_longitude=central_lon)
elif projection == 'LambertCylindrical':
proj = ccrs.LambertCylindrical(central_longitude=central_lon)
elif projection == 'Mercator':
proj = ccrs.Mercator(central_longitude=central_lon)
elif projection == 'Miller':
proj = ccrs.Miller(central_longitude=central_lon)
elif projection == 'Mollweide':
proj = ccrs.Mollweide(central_longitude=central_lon)
elif projection == 'Orthographic':
proj = ccrs.Orthographic(central_longitude=central_lon)
elif projection == 'Robinson':
proj = ccrs.Robinson(central_longitude=central_lon)
elif projection == 'Sinusoidal':
proj = ccrs.Sinusoidal(central_longitude=central_lon)
elif projection == 'NorthPolarStereo':
proj = ccrs.NorthPolarStereo(central_longitude=central_lon)
elif projection == 'SouthPolarStereo':
proj = ccrs.SouthPolarStereo(central_longitude=central_lon)
else:
raise ValidationError('illegal projection: "%s"' % projection)
figure = plt.figure(figsize=(8, 4))
ax = plt.axes(projection=proj)
if extents:
ax.set_extent(extents, ccrs.PlateCarree())
else:
ax.set_global()
ax.coastlines()
if not animate_dim:
animate_dim = 'time'
indexers[animate_dim] = var[animate_dim][0]
var_data = get_var_data(var, indexers, remaining_dims=('lon', 'lat'))
with monitor.starting("animate", len(var[animate_dim]) + 3):
if true_range:
data_min, data_max = _get_min_max(var, monitor=monitor)
else:
data_min, data_max = _get_min_max(var_data, monitor=monitor)
cmap_params = determine_cmap_params(data_min, data_max, **cmap_params)
plot_kwargs = {**properties, **cmap_params}
# Plot the first frame to set-up the axes with the colorbar properly
# transform keyword is for the coordinate our data is in, which in case of a
# 'normal' lat/lon dataset is PlateCarree.
if contour_plot:
var_data.plot.contourf(ax=ax, transform=ccrs.PlateCarree(), subplot_kws={'projection': proj},
add_colorbar=True, **plot_kwargs)
else:
var_data.plot.pcolormesh(ax=ax, transform=ccrs.PlateCarree(), subplot_kws={'projection': proj},
add_colorbar=True, **plot_kwargs)
if title:
ax.set_title(title)
figure.tight_layout()
monitor.progress(1)
def run(value):
ax.clear()
if extents:
ax.set_extent(extents, ccrs.PlateCarree())
else:
ax.set_global()
ax.coastlines()
indexers[animate_dim] = value
var_data = get_var_data(var, indexers, remaining_dims=('lon', 'lat'))
var_data.plot.contourf(ax=ax, transform=ccrs.PlateCarree(), subplot_kws={'projection': proj},
add_colorbar=False, **plot_kwargs)
if title:
ax.set_title(title)
monitor.progress(1)
return ax
anim = animation.FuncAnimation(figure, run, [i for i in var[animate_dim]],
interval=interval, blit=False, repeat=False)
anim_html = anim.to_jshtml()
# Prevent the animation for running after it's finished
del anim
# Delete the rogue temp-file
try:
os.remove('None0000000.png')
except FileNotFoundError:
pass
if file:
with open(file, 'w') as outfile:
outfile.write(anim_html)
monitor.progress(1)
return HTML(anim_html)
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
sia_a = add_cyclic_point(sia_a)
sih_a = add_cyclic_point(sih_a)
land_mask_a = add_cyclic_point(land_mask)
land_mask_a2 = np.where(land_mask_a == 1, 1, np.nan)
######################################################
#
# PART 1: COLOR FILL CONTOURS
#
#%%######################################################
plt.close('all')
fig = plt.figure(num=1, figsize=(14, 7))
ax = plt.axes(projection=ccrs.Sinusoidal(central_longitude=-60))
vmax = 2.3
vmax = 2.0
mp.rcParams['axes.linewidth'] = .05
mp.rcParams['lines.linewidth'] = .05
mp.rcParams['patch.linewidth'] = .05
cnt = plt.contourf(lons_a, lats_a, np.zeros(land_mask_a2.shape), levels=2,\
transform=ccrs.PlateCarree(),vmin=-1,vmax=0,colors='black')
# This is the fix for the white lines between contour levels
for c in cnt.collections:
c.set_edgecolor("face")
def _plot(self, data_array):
"""
From the TATSSI Time Series Generator object plots the
extent of data with coastline and political division
"""
# Get projection from first data variable
proj4_string = data_array.crs
# If projection is Sinusoidal
srs = get_projection(proj4_string)
if srs.GetAttrValue('PROJECTION') == 'Sinusoidal':
globe=ccrs.Globe(ellipse=None,
semimajor_axis=6371007.181,
semiminor_axis=6371007.181)
proj = ccrs.Sinusoidal(globe=globe)
else:
proj = None
self.fig, self.ax = plt.subplots(1, 1, figsize=(8, 8),
subplot_kw=dict(projection=proj))
self.extent = self.ax.get_extent()
if proj is not None:
try:
cfeature.BORDERS.geometries()
self.ax.coastlines(resolution='50m', color='black')
self.ax.add_feature(cfeature.BORDERS, edgecolor='black')
except urllib.error.URLError:
pass
# Gridlines
self.ax.gridlines()
# Make all values NaN
# data_array = (data_array.astype(np.float32) * np.nan)
# Plot
data_array[0].plot.imshow(
ax=self.ax, add_colorbar=False, cmap='viridis',
transform=proj
)
self.ax.set_frame_on(False)
self.ax.axis('off')
self.ax.set_aspect('equal')
self.ax.title.set_text('')
# Set plot on the plot widget
self.plotWidget = FigureCanvas(self.fig)
lay = QtWidgets.QVBoxLayout(self.content_plot)
lay.setContentsMargins(0, 40, 0, 0)
lay.addWidget(self.plotWidget)
# Add toolbar
font = QFont()
font.setPointSize(10)
toolbar = NavigationToolbar(self.plotWidget, self)
toolbar.setFont(font)
self.addToolBar(QtCore.Qt.BottomToolBarArea, toolbar)
# Needed in order to use a tight layout with Cartopy axes
self.fig.canvas.draw()
plt.tight_layout()
