def quiverplot(field, field2, lons, lats, colmap, scale, label, leng):
mp = Basemap(lon_0=0, projection='robin')
fig1 = plt.figure()
mp.drawcoastlines()
uproj, vproj, xx, yy = mp.transform_vector(field,
field2,
lons,
lats,
31,
31,
returnxy=True,
masked=True)
lons, lats = np.meshgrid(lons, lats)
a, b = mp(lons, lats)
Q = mp.quiver(xx, yy, uproj, vproj, scale=scale, cmap=colmap)
qk = plt.quiverkey(Q, 0.1, 0.05, leng, label, labelpos='W')
plt.show()
def currents(uin, vin, lons, lats, extent):
m = Basemap(projection='merc',
resolution='l',
llcrnrlon=extent[0],
llcrnrlat=extent[1],
urcrnrlon=extent[2],
urcrnrlat=extent[3])
m.drawmapboundary()
m.drawcoastlines()
m.fillcontinents()
m.drawparallels(np.arange(24., 38, 2.),
labels=[1, 0, 0, 0],
fontsize=8)
m.drawmeridians(np.arange(120., 144, 2.),
labels=[0, 0, 0, 1],
fontsize=8)
vLat = int((max(lats) - min(lats)) * 6)
vLon = int((max(lons) - min(lons)) * 6)
print(min(lons), min(lats), max(lons), max(lats))
uRot, vRot, x, y = m.transform_vector(uin,
vin,
lons,
lats,
vLon,
vLat,
returnxy=True)
C = m.contourf(x, y, np.hypot(uRot, vRot), cmap='Blues')
cb = m.colorbar(C, size=0.2, pad=0.05, location='right')
cb.set_label('Current velocity [kn]', rotation=270, labelpad=15)
Q = m.quiver(x,
y,
uRot,
vRot,
np.hypot(uRot, vRot),
cmap='Greys',
pivot='mid',
width=0.002,
headlength=4,
scale=90)
# plt.quiverkey(Q, 0.45, -0.1, 2, r'$2$ knots', labelpos='E')
# plt.savefig(DIR / 'output/figures' / 'KC_data.pdf', bbox_inches='tight', pad_inches=0.3)
plt.show()
# parallels, meridians and title.
for nt, date in enumerate(dates):
CS = m.contour(x, y, slp[nt, :, :], clevs, linewidths=0.5, colors="k", animated=True)
CS = m.contourf(x, y, slp[nt, :, :], clevs, cmap=plt.cm.RdBu_r, animated=True)
# plot wind vectors on lat/lon grid.
# rotate wind vectors to map projection coordinates.
# urot,vrot = m.rotate_vector(u[nt,:,:],v[nt,:,:],lons,lats)
# plot wind vectors over map.
# Q = m.quiver(x,y,urot,vrot,scale=500)
# plot wind vectors on projection grid (looks better).
# first, shift grid so it goes from -180 to 180 (instead of 0 to 360
# in longitude). Otherwise, interpolation is messed up.
ugrid, newlons = shiftgrid(180.0, u[nt, :, :], longitudes, start=False)
vgrid, newlons = shiftgrid(180.0, v[nt, :, :], longitudes, start=False)
# transform vectors to projection grid.
urot, vrot, xx, yy = m.transform_vector(ugrid, vgrid, newlons, latitudes, 51, 51, returnxy=True, masked=True)
# plot wind vectors over map.
Q = m.quiver(xx, yy, urot, vrot, scale=500)
# make quiver key.
qk = plt.quiverkey(Q, 0.1, 0.1, 20, "20 m/s", labelpos="W")
# draw coastlines, parallels, meridians, title.
m.drawcoastlines(linewidth=1.5)
m.drawparallels(parallels)
m.drawmeridians(meridians)
plt.title("SLP and Wind Vectors " + str(date))
if nt == 0: # plot colorbar on a separate axes (only for first frame)
cax = plt.axes([l + w - 0.05, b, 0.03, h]) # setup colorbar axes
fig.colorbar(CS, drawedges=True, cax=cax) # draw colorbar
cax.text(0.0, -0.05, "mb")
plt.axes(ax) # reset current axes
plt.draw() # draw the plot
clevs = np.arange(960,1061,5)
# compute native x,y coordinates of grid.
x, y = m(lons, lats)
# define parallels and meridians to draw.
parallels = np.arange(-80.,90,20.)
meridians = np.arange(0.,360.,20.)
# plot SLP contours.
CS1 = m.contour(x,y,slp,clevs,linewidths=0.5,colors='k',animated=True)
CS2 = m.contourf(x,y,slp,clevs,cmap=plt.cm.RdBu_r,animated=True)
# plot wind vectors on projection grid.
# first, shift grid so it goes from -180 to 180 (instead of 0 to 360
# in longitude). Otherwise, interpolation is messed up.
ugrid,newlons = shiftgrid(180.,u,longitudes,start=False)
vgrid,newlons = shiftgrid(180.,v,longitudes,start=False)
# transform vectors to projection grid.
uproj,vproj,xx,yy = \
m.transform_vector(ugrid,vgrid,newlons,latitudes,31,31,returnxy=True,masked=True)
# now plot.
Q = m.quiver(xx,yy,uproj,vproj,scale=700)
# make quiver key.
qk = plt.quiverkey(Q, 0.1, 0.1, 20, '20 m/s', labelpos='W')
# draw coastlines, parallels, meridians.
m.drawcoastlines(linewidth=1.5)
m.drawparallels(parallels)
m.drawmeridians(meridians)
# add colorbar
cb = m.colorbar(CS2,"bottom", size="5%", pad="2%")
cb.set_label('hPa')
# set plot title
ax.set_title('SLP and Wind Vectors '+str(date))
plt.show()
lat_0=((np.max(sst.lat) - np.min(sst.lat)) / 2),
lon_0=((np.max(sst.lon) - np.min(sst.lon)) / 2),
llcrnrlon=np.min(sst.lon),
llcrnrlat=np.min(sst.lat),
urcrnrlon=np.max(sst.lon),
urcrnrlat=np.max(sst.lat))
# Fix OSCAR data for map
oscar_map_lat = np.asarray(oscar_u.latitude)
oscar_map_lon = np.asarray(oscar_u.longitude) - 360.
oscar_map_u = np.squeeze(np.asarray(oscar_u.u))
oscar_map_v = np.squeeze(np.asarray(oscar_v.v))
uproj, vproj, xx, yy = map.transform_vector(np.flipud(oscar_map_u),
np.flipud(oscar_map_v),
oscar_map_lon,
np.flipud(oscar_map_lat),
31,
31,
returnxy=True,
masked=True)
plt.clf()
plt.suptitle('NOAA CoastWatch & JPL OSCAR: ' +
datetime.datetime(yyyy, mm, dd).strftime("%d %b %Y"),
fontsize=36,
family='Helvetica')
plt.subplot(2, 2, 1)
map = Basemap(projection='merc',
resolution='i',
lat_0=((np.max(sst.lat) - np.min(sst.lat)) / 2),
lon_0=((np.max(sst.lon) - np.min(sst.lon)) / 2),
def plot_seasonal_winds(samples_folder, seasons=commons.default_seasons, level_hpa=850):
long_name = "Wind at {}hPa".format(level_hpa)
file_prefix = "dp"
plot_units = "m/s"
mult_coeff = 0.5144444444
add_offset = 0
out_dx = 0.5
lons2d, lats2d, u_season_to_mean, v_season_to_mean = calculate_seasonal_mean_winds(seasons=seasons,
level_hpa=level_hpa,
samples_folder=samples_folder,
file_prefix=file_prefix)
# Plotting ++++++++++++++++++
plot_utils.apply_plot_params(width_cm=25, height_cm=15, font_size=18)
fig = plt.figure()
ncols = 2
gs = GridSpec(len(u_season_to_mean) // ncols + int(not (len(u_season_to_mean) % ncols == 0)), ncols, wspace=0, hspace=0)
xx, yy = None, None
bmp = Basemap(projection="robin", lon_0=0)
cmap = cm_basemap.GMT_no_green
clevs = None
for i, (sname, u_field) in enumerate(u_season_to_mean.items()):
row = i // ncols
col = i % ncols
ax = fig.add_subplot(gs[row, col])
lons, lats, u = commons.interpolate_to_uniform_global_grid(u_field, lons_in=lons2d, lats_in=lats2d, out_dx=out_dx)
_, _, v = commons.interpolate_to_uniform_global_grid(v_season_to_mean[sname], lons_in=lons2d, lats_in=lats2d, out_dx=out_dx)
if xx is None:
xx, yy = bmp(lons, lats)
cs = bmp.contourf(xx, yy, (u ** 2 + v ** 2) ** 0.5 * mult_coeff, 20 if clevs is None else clevs, cmap=cmap, extend="max")
uproj, vproj, xx_uv, yy_uv = bmp.transform_vector(u.transpose(), v.transpose(),
lons[:, 0], lats[0, :], lons.shape[0],
lats.shape[1], returnxy=True)
step = 15
qkey = bmp.quiver(xx_uv[::step, ::step], yy_uv[::step, ::step], uproj[::step, ::step], vproj[::step, ::step], scale=700)
# save color levels for next subplots
clevs = cs.levels
ax.set_title(sname)
cb = plt.colorbar(cs, ax=ax)
if not (row == 0 and col == ncols - 1):
# cb.ax.set_title(plot_units)
cb.ax.set_visible(False)
bmp.drawcoastlines(ax=ax, linewidth=LINEWIDTH)
fig.suptitle("{}, {}".format(long_name, plot_units))
img_folder = samples_folder.joinpath("images/seasonal")
if not img_folder.is_dir():
img_folder.mkdir(parents=True)
img_file = img_folder.joinpath("wind_vectors_{}hPa.eps".format(level_hpa))
with img_file.open("wb") as f:
fig.savefig(f, format="eps", bbox_inches="tight")
plt.close(fig)
def geoplot(data=None, lon=None, lat=None, **kw):
'''Show 2D data in a lon-lat plane.
Parameters
-----------
data: array (ndarray or DataArray) of shape (n_lat, n_lon),
or [u_array, v_array]-like for (u,v) data
or None(default) when only plotting the basemap.
lon: n_lon length vector or None(default).
lat: n_lat length vector or None(default).
kw: dict parameters related to basemap or plot functions.
Basemap related parameters:
----------------------------
basemap_kw: dict parameter in the initialization of a Basemap.
proj or projection: map projection name (default is 'hammer')
popular projections: 'cyl', 'ortho', 'hammer', 'lcc', 'laea'
'np'(='nplaea'), 'sp'(='splaea')
and other projections given from basemap.
lon_0: map center longitude (0 as default).
lat_0: map center latitude (0 as default).
lonlatcorner: (llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat).
boundinglat: latitude at the map out boundary (None as default).
basemap_round or round: True(default) or False.
basemap_width: width of basemap in projections like 'lcc' or 'laea'
basemap_height: height of basemap in projections like 'lcc' or 'laea'
land_on: bool value (False as default).
land_kw: dict parameter used in the Basemap.fillcontinents method.
land_color: color of land ('0.33' as default).
lake_color: color of lakes ('none' as default).
ocean_on: bool value (False as default).
ocean_color: color of ocean ([ 0.59375, 0.71484375, 0.8828125] as default).
coastline_on: bool value (default True if both land and ocean are not shown)
coastline_kw: dict parameter used in the Basemap.drawcoastlines method.
coastline_color: color of coast lines ('0.33' as default).
grid_on: bool value (True as default).
grid_label_on: bool value (False as default).
parallel_kw: dict parameters used in the Basemap.drawparallels method.
parallels: parallels to be drawn (None as default).
parallel_color: color of parallels ('0.5' as default).
parallel_labels:[0,0,0,0] or [1,0,0,0].
meridian_kw: dict parameters used in the Basemap.drawmeridians method.
meridians: meridians to be drawn (None as default).
meridian_color: color of meridians (parallels_color as default).
meridian_labels: [0,0,0,0] or [0,0,0,1].
lonlatbox: None or (lon_start, lon_end, lat_start, lat_end).
lonlatbox_kw: dict parameters in the plot of lon-lat box.
lonlatbox_color:
General plot parameters:
-------------------------
ax: axis object, default is plt.gca()
plot_type: a string of plot type from ('pcolor', 'pcolormesh', 'imshow', 'contourf', 'contour', 'quiver', 'scatter') or None(default).
cmap: pyplot colormap.
clim: a tuple of colormap limit.
levels: sequence, int or None (default=None)
Pcolor/Pcolormesh related parameters:
-------------------------------
rasterized: bool (default is True).
Imshow related parameters
---------------------------
origin: 'lower' or 'upper'.
extent: horizontal range.
interpolation: 'nearest' (default) or 'bilinear' or 'cubic'.
Contourf related parameters:
-------------------------------
extend: 'both'(default).
Contour related parameters:
----------------------------
label_contour: False(default) or True.
Whether to label contours or not.
colors: contour color (default is 'gray').
Quiver plot related parameters:
--------------------------------
quiver_scale: quiver scale.
quiver_color: quiver color.
quiver_kw: dict parameters used in the plt.quiver function.
regrid_shape: int or tuple.
qkey_on: bool value, whether to show the quiverkey plot.
qkey_X: X parameter in the plt.quiverkey function (default is 0.85).
qkey_Y: Y parameter in the plt.quiverkey function (default is 1.02).
qkey_U: U parameter in the plt.quiverkey function (default is 2).
qkey_label: label parameter in the plt.quiverkey function.
qkey_labelpos: labelpos parameter in the plt.quiverkey function.
qkey_kw: dict parameters used in the plt.quiverkey function.
Scatter related parameters:
------------------------------
scatter_data: None(default) or (lonvec, latvec).
Hatch plot related parameters:
----------------------------------
hatches: ['///'] is default.
Colorbar related parameters:
-------------------------------
cbar_on: bool value, whether to show the colorbar.
cbar_type: 'vertical'(shorten as 'v') or 'horizontal' (shorten as 'h').
cbar_extend: extend parameter in the plt.colorbar function.
'neither' as default here.
cbar_size: default '2.5%' for vertical colorbar,
'5%' for horizontal colorbar.
cbar_pad: default 0.1 for vertical colorbar,
0.4 for horizontal colorbar.
cbar_kw: dict parameters used in the plt.colorbar function.
units: str
long_name: str
Returns
--------
basemap object if only basemap is plotted.
plot object if data is shown.
'''
#### extract data into ndarray dtypes (zz, lon, lat), might be modified after lon_0 is determined (lon-shifted)
# data
data_is_vector_field = isinstance(data, (list, tuple)) \
and len(data) == 2
if data_is_vector_field: # input data are (u,v) type, in this case u = data[0], v = data[1]
data1 = data[1] # v
data = data[0] # u
# zz
try:
zz = data.values # data is an xarray.DataArray
except:
zz = data
# uu, vv
if data_is_vector_field: # input data are (u,v) type
try: # data1 is DataArray
vv = data1.values
except: # data1 is ndarray
vv = data1
uu = zz
zz = np.sqrt(uu**2 + vv**2) # magnitude of the vector field
# lon
if lon is None:
try: # data is DataArray
lon = [data[dim].values for dim in data.dims
if dim in ['lon', 'longitude', 'X', 'Lon', 'Longitude']][0]
except:
try: # data and zz are ndarray
nx = zz.shape[-1]
except: # data and zz are None
nx = 180
lon = np.linspace(0, 360, nx+1)[:-1]
# lat
if lat is None:
try: # data is DataArray
lat = [data[dim].values for dim in data.dims
if dim in ['lat', 'latitude', 'Y']][0]
except:
try: # data and zz are ndarray
ny = zz.shape[0]
except: # data and zz are None
ny = 90
lat_ = np.linspace(-90, 90, ny+1) # lat grid edges
lat = (lat_[0:-1] + lat_[1:])/2
if lat[-1] < lat[0]: #lat is in descending order
lat = lat[-1::-1]
zz = zz[-1::-1, :]
if data_is_vector_field:
uu = uu[-1::-1, :]
vv = vv[-1::-1, :]
#### target axis
ax = kw.pop('ax', None)
if ax is None:
ax = plt.gca()
else:
plt.sca(ax)
# #### basemap parameters
basemap_kw = kw.pop('basemap_kw', {})
# projection
proj = kw.pop('proj', 'hammer')
proj = kw.pop('projection', proj) # projection overrides the proj parameter
proj = basemap_kw.pop('projection', proj)
# short names for nplaea and splaea projections
if proj in ('npolar', 'polar', 'np'):
proj = 'nplaea'
elif proj in ('spolar', 'sp'):
proj = 'splaea'
# lon_0: might shift the original lon and zz
if proj in ('lcc', 'laea'):
lon_0 = kw.pop('lon_0', -100) # center longitude prescribed
else:
if np.isclose( np.abs(lon[-1]-lon[0]+lon[-1]-lon[-2]), 360 ):
lon_0 = kw.pop('lon_0', 0) # center longitude prescribed
else:
lon_0 = kw.pop('lon_0', (lon[0]+lon[-1])/2)
if proj in ('moll', 'cyl', 'hammer', 'robin', 'kav7') \
and np.isclose( np.abs(lon[-1]-lon[0]+lon[-1]-lon[-2]), 360 ):
# modify lon_0
lon_0 = basemap_kw.pop('lon_0', lon_0)
lon_0_data = (lon[0] + lon[-1])/2.0 # center longitude of data coverage
dlon = lon[1] - lon[0] # lon grid size of data
d_lon_0 = lon_0 - lon_0_data # distance between specified center lon and data center lon
lon_0 = float(int(d_lon_0/dlon)) * dlon + lon_0_data # modified version of the specified lon_0
# shift grid: only needed in some projections
lon_west_end = lon_0 - 180 + (lon[1] - lon[0])/2.0
# make sure the longitude of west end within the lon
if lon_west_end < lon.min():
lon_west_end += 360
elif lon_west_end > lon.max():
lon_west_end -= 360
try:
zz, lon_ = shiftgrid(lon_west_end, zz, lon, start=True)
except: # zz is None
dummy, lon_ = shiftgrid(lon_west_end, lon, lon, start=True)
if data_is_vector_field:
uu, lon_ = shiftgrid(lon_west_end, uu, lon, start=True)
vv, lon_ = shiftgrid(lon_west_end, vv, lon, start=True)
lon = lon_
# make sure lon_0 within the shifted lon
if lon.min() > lon_0:
lon -= 360
elif lon.max() < lon_0:
lon += 360
# lat_0
if proj in ('lcc', 'laea'):
lat_0 = kw.pop('lat_0', 50)
else:
lat_0 = kw.pop('lat_0', 0)
lat_0 = basemap_kw.pop('lat_0', lat_0)
# lonlatcorner = (llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat)
lonlatcorner = kw.pop('lonlatcorner', None)
if lonlatcorner is not None:
llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat = lonlatcorner
else:
llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat = (None,) * 4
llcrnrlon = basemap_kw.pop('llcrnrlon', llcrnrlon)
urcrnrlon = basemap_kw.pop('urcrnrlon', urcrnrlon)
llcrnrlat = basemap_kw.pop('llcrnrlat', llcrnrlat)
urcrnrlat = basemap_kw.pop('urcrnrlat', urcrnrlat)
# boundinglat
boundinglat = kw.pop('boundinglat', None)
boundinglat = basemap_kw.pop('boundinglat', boundinglat)
if boundinglat is None:
if proj in ('npstere', 'nplaea', 'npaeqd'):
boundinglat = 30
elif proj in ('spstere', 'splaea', 'spaeqd'):
boundinglat = -30
# basemap round: True or False
if proj in ('npstere', 'nplaea', 'npaeqd', 'spstere', 'splaea', 'spaeqd'):
basemap_round = kw.pop('basemap_round', True)
else:
basemap_round = kw.pop('basemap_round', False)
basemap_round = basemap_kw.pop('round', basemap_round)
# basemap width and height
if proj in ('lcc', 'laea'):
basemap_width = kw.pop('basemap_width', 120e5)
basemap_height = kw.pop('basemap_height', 90e5)
else:
basemap_width = kw.pop('basemap_width', None)
basemap_height = kw.pop('basemap_height', None)
basemap_width = basemap_kw.pop('width', basemap_width)
basemap_height = basemap_kw.pop('height', basemap_height)
# base map
m = Basemap(projection=proj, lon_0=lon_0, lat_0=lat_0, boundinglat=boundinglat,
round=basemap_round,
llcrnrlon=llcrnrlon, urcrnrlon=urcrnrlon,
llcrnrlat=llcrnrlat, urcrnrlat=urcrnrlat,
width=basemap_width, height=basemap_height,
**basemap_kw)
# test
'''
print('projection', proj)
print('lon_0', lon_0)
print('lat_0', lat_0)
print('round', basemap_round)
print('llcrnrlon', llcrnrlon)
print('urcrnrlon', urcrnrlon)
print('llcrnrlat', llcrnrlat)
print('urcrnrlat', urcrnrlat)
print('width', basemap_width)
print('height', basemap_height)
'''
# show continents or plot coast lines
# ocean
ocean_on = kw.pop('ocean_on', False)
default_ocean_color = [ 0.59375, 0.71484375, 0.8828125]
ocean_color = kw.pop('ocean_color', default_ocean_color)
if ocean_on:
m.drawmapboundary(fill_color=ocean_color)
# land
land_on = kw.pop('land_on', False)
land_kw = kw.pop('land_kw', {})
land_color = kw.pop('land_color', '0.33')
land_color = land_kw.pop('color', land_color)
lake_color = kw.pop('lake_color', 'none')
lake_color = land_kw.pop('lake_color', lake_color)
if land_on :
# use Basemap.fillcontinents method
m.fillcontinents(color=land_color, lake_color=lake_color,
**land_kw)
# coastlines
coastline_on = kw.pop('coastline_on', not land_on)
if coastline_on:
coastline_kw = kw.pop('coastline_kw', {})
# use Basemap.drawcoastlines method
coastline_color = kw.pop('coastline_color', '0.33')
coastline_color = coastline_kw.pop('color', coastline_color)
coastline_lw = kw.pop('coastline_lw', 0.5)
coastline_lw = coastline_kw.pop('linewidth', coastline_lw)
m.drawcoastlines(color=coastline_color, linewidth=coastline_lw,
**coastline_kw)
# parallels
grid_on = kw.pop('grid_on', True)
parallel_kw = kw.pop('parallel_kw', {})
grid_label_on = kw.pop('grid_label_on', False)
parallels = kw.pop('parallels', None)
parallel_color = kw.pop('parallel_color', '0.5')
parallel_color = parallel_kw.pop('color', parallel_color)
parallel_lw = kw.pop('parallel_lw', 0.5)
parallel_lw = parallel_kw.pop('linewidth', parallel_lw)
parallel_labels = kw.pop('parallel_labels', None)
parallel_labels = parallel_kw.pop('labels', parallel_labels)
if parallel_labels is None:
if grid_label_on:
parallel_labels = [1, 0, 0, 0]
else:
parallel_labels = [0, 0, 0, 0]
if parallels is not None:
m.drawparallels(parallels, color=parallel_color,
labels=parallel_labels,
linewidth=parallel_lw, **parallel_kw)
elif grid_on:
m.drawparallels(np.arange(-90, 91, 30), color=parallel_color,
linewidth=parallel_lw, labels=parallel_labels,
**parallel_kw)
# meridians
meridians = kw.pop('meridians', None)
meridian_kw = kw.pop('meridian_kw', {})
meridian_color = kw.pop('meridian_color', parallel_color)
meridian_color = meridian_kw.pop('color', meridian_color)
meridian_lw = kw.pop('meridian_lw', parallel_lw)
meridian_lw = meridian_kw.pop('linewidth',meridian_lw)
meridian_labels = kw.pop('meridian_labels', None)
meridian_labels = meridian_kw.pop('labels', meridian_labels)
if meridian_labels is None:
if grid_label_on:
if proj in ('npstere', 'nplaea', 'npaeqd',
'spstere', 'splaea', 'spaeqd'):
meridian_labels = [1, 1, 0, 0]
elif proj in ('hammer', 'moll'):
meridian_labels = [0, 0, 0, 0]
else:
meridian_labels = [0, 0, 0, 1]
else:
meridian_labels = [0, 0, 0, 0]
if meridians is not None:
m.drawmeridians(meridians, color=meridian_color,
label=meridian_labels,
linewidth=meridian_lw, **meridian_kw)
elif grid_on:
m.drawmeridians(np.arange(0, 360, 30), color=meridian_color,
labels=meridian_labels,
linewidth=meridian_lw,
**meridian_kw)
# lonlatbox
lonlatbox = kw.pop('lonlatbox', None)
if lonlatbox is not None:
lonlon = np.array([
np.linspace(lonlatbox[0], lonlatbox[1], 100),
lonlatbox[1]*np.ones(100),
np.linspace(lonlatbox[1], lonlatbox[0], 100),
lonlatbox[0]*np.ones(100)
]).ravel()
latlat = np.array([
lonlatbox[2]*np.ones(100),
np.linspace(lonlatbox[2], lonlatbox[3], 100),
lonlatbox[3]*np.ones(100),
np.linspace(lonlatbox[3], lonlatbox[2], 100)
]).ravel()
lonlatbox_kw = kw.pop('lonlatbox_kw', {})
lonlatbox_color = kw.pop('lonlatbox_color', 'k')
lonlatbox_color = lonlatbox_kw.pop('color', lonlatbox_color)
m.plot(lonlon, latlat, latlon=True, color=lonlatbox_color, **lonlatbox_kw)
# #### stop here and return the map object if data is None
if data is None:
return m
# ###### plot parameters
# plot_type
plot_type = kw.pop('plot_type', None)
if plot_type is None:
if data_is_vector_field:
plot_type = 'quiver'
elif proj in ('nplaea', 'splaea', 'ortho'):
# pcolormesh has a problem for these projections
plot_type = 'pcolor'
else:
plot_type = 'pcolormesh'
print ('plot_type **** {} **** is used.'.format(plot_type))
# cmap
cmap = kw.pop('cmap', None)
if cmap is None:
zz_max = data.max()
zz_min = data.min()
if zz_min >=0:
try:
cmap = plt.get_cmap('viridis')
except:
cmap = plt.get_cmap('OrRd')
elif zz_max<=0:
try:
cmap = plt.get_cmap('viridis')
except:
cmap = plt.get_cmap('Blues_r')
else:
cmap = plt.get_cmap('RdBu_r')
elif isinstance(cmap, str):
cmap = plt.get_cmap(cmap)
# clim parameters
clim = kw.pop('clim', None)
robust = kw.pop('robust', False)
if clim is None:
if isinstance(zz,np.ma.core.MaskedArray):
zz1d = zz.compressed()
else:
zz1d = zz.ravel()
notNaNs = np.logical_not(np.isnan(zz1d))
zz1d = zz1d[notNaNs]
if robust:
a = np.percentile(zz1d,2)
b = np.percentile(zz1d,98)
else:
a = zz1d.min()
b = zz1d.max()
if a * b < 0:
b = max(abs(a), abs(b))
a = -b
clim = a, b
# levels
levels = kw.pop('levels', None)
if levels is None:
if plot_type in ('contour', 'contourf', 'contourf+'):
a, b = clim
levels = np.linspace(a, b, 11)
elif isinstance(levels, int):
if plot_type in ('contour', 'contourf', 'contourf+'):
a, b = clim
levels = np.linspace(a, b, levels)
elif plot_type in ('pcolor', 'pcolormesh', 'imshow'):
cmap = plt.get_cmap(cmap.name, levels-1)
else: # levels is a sequence
if plot_type in ('pcolor', 'pcolormesh', 'imshow'):
cmap = plt.get_cmap(cmap.name, len(levels)-1)
clim = min(levels), max(levels)
# colorbar parameters
cbar_on = kw.pop('cbar_on', None)
cbar_kw = kw.pop('cbar_kw', {})
cbar_location = kw.pop('cbar_location', 'right')
if cbar_location in ('right', 'left'):
cbar_size = kw.pop('cbar_size', '2.5%')
cbar_pad = kw.pop('cbar_pad', '2.5%')
elif cbar_location in ('bottom', 'top'):
cbar_size = kw.pop('cbar_size', '5%')
cbar_pad = kw.pop('cbar_pad', '5%')
# units in colorbar
units = kw.pop('units', None)
if units is None:
try:
units = data.attrs['units'] # input data is a DataArray
except:
units = ''
# long_name in colorbar
long_name = kw.pop('long_name', None)
if long_name is None:
try:
long_name = data['long_name'] # if input data is a DataArray
if long_name is None:
long_name = ''
except:
long_name = ''
# lon and lat edges
lon_extend = np.hstack((2*lon[0] - lon[1], lon, 2*lon[-1] - lon[-2])) # size=nx+2
lon_edge = (lon_extend[:-1] + lon_extend[1:])/2.0 # size=nx+1
lat_extend = np.hstack((2*lat[0] - lat[1], lat, 2*lat[-1] - lat[-2])) # size=nx+2
lat_edge = (lat_extend[:-1] + lat_extend[1:])/2.0 # size=nx+1
# add cyclic point in some projections and plot types
if plot_type in ('contourf', 'contour', 'contourf+') \
and proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere',
'splaea', 'spaeqd')\
and np.isclose(np.abs(lon_edge[-1]-lon_edge[0]), 360):
zz, lon = addcyclic(zz, lon)
# final data preparation before plotting
Lon, Lat = np.meshgrid(lon, lat)
X, Y = m(Lon, Lat)
Lon_edge, Lat_edge = np.meshgrid(lon_edge, lat_edge)
X_edge, Y_edge = m(Lon_edge, Lat_edge)
if np.any(np.isnan(zz)):
zz = ma.masked_invalid(zz) # mask invalid values
# ###### plot
# pcolor
if plot_type in ('pcolor',):
rasterized = kw.pop('rasterized', True)
plot_obj = m.pcolor(X_edge, Y_edge, zz, cmap=cmap,
rasterized=rasterized, **kw)
# pcolormesh
elif plot_type in ('pcolormesh',):
rasterized = kw.pop('rasterized', True)
plot_obj = m.pcolormesh(X_edge, Y_edge, zz, cmap=cmap,
rasterized=rasterized, **kw)
# imshow
elif plot_type in ('imshow',):
if lat_edge[-1] > lat_edge[0]:
origin = kw.pop('origin', 'lower')
else:
origin = kw.pop('origin', 'upper')
extent = kw.pop('extent', [lon_edge[0], lon_edge[-1], lat_edge[0], lat_edge[-1]])
interpolation = kw.pop('interpolation', 'nearest')
plot_obj = m.imshow(zz, origin=origin, cmap=cmap, extent=extent,
interpolation=interpolation, **kw)
# contourf, contour and contourf+
# contourf
elif plot_type in ('contourf',):
extend = kw.pop('extend', 'both')
plot_obj = m.contourf(X, Y, zz, extend=extend, cmap=cmap,
levels=levels, **kw)
# contour
elif plot_type in ('contour',):
colors = kw.pop('colors', 'k')
if colors is not None:
cmap = None
alpha = kw.pop('alpha', 0.5)
plot_obj = m.contour(X, Y, zz, cmap=cmap, colors=colors,
levels=levels, alpha=alpha, **kw)
contour_label_on = kw.pop('contour_label_on', False)
if contour_label_on:
plt.clabel(plot_obj,plot_obj.levels[::2],fmt='%.2G')
# contourf + contour
elif plot_type in ('contourf+',):
extend = kw.pop('extend', 'both')
linewidths = kw.pop('linewidths', 1)
plot_obj = m.contourf(X, Y, zz, extend=extend, cmap=cmap,
levels=levels, **kw)
colors = kw.pop('colors', 'k')
if colors is not None:
cmap = None
alpha = kw.pop('alpha', 0.5)
m.contour(X, Y, zz, cmap=cmap, colors=colors, alpha=alpha,
levels=levels, linewidths=linewidths, **kw)
# quiverplot
elif plot_type in ('quiver',):
regrid_shape = kw.pop('regrid_shape', (40, 40))
if isinstance(regrid_shape, int):
regrid_shape = (regrid_shape,) * 2
nx, ny = regrid_shape
# need to shift grid if lon is out of the [-180, 180] range
if lon.max() > 180 or lon.min() < -180:
uu, lon_ = shiftgrid(180.,uu,lon,start=False)
vv, lon_ = shiftgrid(180.,vv,lon,start=False)
lon = lon_
uu, vv, X, Y = m.transform_vector(
uu, vv, lon, lat, nx, ny, returnxy=True
)
magnitude_on = kw.pop('magnitude_on', False)
quiver_color = kw.pop('quiver_color', 'g')
quiver_scale = kw.pop('quiver_scale', None)
# quiverkey params
qkey_kw = kw.pop('qkey_kw', {})
qkey_on = kw.pop('qkey_on', True)
qkey_X = kw.pop('qkey_X', 0.9)
qkey_X = qkey_kw.pop('X', qkey_X)
qkey_Y = kw.pop('qkey_Y', 1.03)
qkey_Y = qkey_kw.pop('Y', qkey_Y)
qkey_U = kw.pop('qkey_U', np.nanmax(zz))
qkey_U = qkey_kw.pop('U', qkey_U)
qkey_label = kw.pop('qkey_label', '{:.2g} '.format(qkey_U) + units)
qkey_label = qkey_kw.pop('label', qkey_label)
qkey_labelpos = kw.pop('qkey_labelpos', 'W')
qkey_labelpos = qkey_kw.pop('labelpos', qkey_labelpos)
if magnitude_on:
magnitude = np.sqrt(uu**2 + vv**2)
plot_obj = m.quiver(X, Y, uu, vv, magnitude, color=quiver_color,
scale=quiver_scale, **kw)
else:
plot_obj = m.quiver(X, Y, uu, vv, color=quiver_color,
scale=quiver_scale, **kw)
if qkey_on:
# quiverkey plot
plt.quiverkey(plot_obj, qkey_X, qkey_Y, qkey_U,
label=qkey_label, labelpos=qkey_labelpos, **qkey_kw)
# hatch plot
elif plot_type in ('hatch', 'hatches'):
# hatches = kw.pop('hatches', ['///'])
hatches = kw.pop('hatches', ['...'])
plot_obj = m.contourf(X, Y, zz, colors='none', hatches=hatches,
extend='both', **kw)
else:
print('Please choose a right plot_type from ("pcolor", "contourf", "contour")!')
# set clim
if plot_type in ('pcolor', 'pcolormesh', 'imshow'):
plt.clim(clim)
# plot colorbar
if cbar_on is None:
if plot_type in ('pcolor', 'pcolormesh', 'contourf', 'contourf+',
'imshow'):
cbar_on = True
elif (plot_type in ('quiver',) and magnitude_on):
cbar_on = True
else:
cbar_on = False
if cbar_on:
cbar = m.colorbar(plot_obj, location=cbar_location,
size=cbar_size, pad=cbar_pad, ax=ax, **cbar_kw)
if cbar_location in ('right',):
cbar.ax.xaxis.set_label_position('top')
cbar.ax.set_xlabel(units)
cbar.ax.set_ylabel(long_name)
elif cbar_location in ('bottom',):
if long_name == '' or units =='':
cbar.ax.set_xlabel('{}{}'.format(long_name, units))
else:
cbar.ax.set_xlabel('{} [{}]'.format(long_name, units))
return plot_obj
class Plot:
def __init__(self, figsize=(7, 5), dpi=180):
self.mmnote = ''
self.family = 'Lato'
self.dpi = dpi
self.fig = plt.figure(figsize=figsize)
self.ax = plt.gca()
self.fontsize = dict(title=6,
timestamp=5,
mmnote=5,
clabel=5,
cbar=5,
gridvalue=5,
mmfilter=6,
parameri=4,
legend=6,
marktext=5)
self.linecolor = dict(coastline='#222222',
country='#222222',
province='#222222',
city='#222222',
county='#222222',
parameri='k')
self.mpstep = 10
def setfamily(self, f):
self.family = f
def setfontsize(self, name, size):
self.fontsize.update({name: size})
def setlinecolor(self, name, size):
self.linecolor.update({name: size})
def setdpi(self, dpi):
self.dpi = dpi
def setmeriparastep(self, mpstep):
self.mpstep = mpstep
def setxy(self, georange, res):
self.latmin, self.latmax, self.lonmin, self.lonmax = tuple(georange)
if self.lonmin == 0 and self.lonmax == 360:
self.x = np.arange(0, 360, res)
else:
self.x = np.arange(self.lonmin, self.lonmax + res, res)
self.y = np.arange(self.latmin, self.latmax + res, res)
self.xx, self.yy = np.meshgrid(self.x, self.y)
self.res = res
if self.trans:
self.nx, self.ny = self.x, self.y
self.x, self.y = self.m(self.xx, self.yy)
def setmap(self, key=None, projection='cyl', resolution='i', **kwargs):
if key == 'chinaproper':
kwargs.update(projection='cyl',
resolution='i',
llcrnrlat=20,
urcrnrlat=40,
llcrnrlon=100,
urcrnrlon=130)
elif key == 'chinamerc':
kwargs.update(projection='merc',
resolution='i',
llcrnrlat=15,
urcrnrlat=55,
llcrnrlon=70,
urcrnrlon=140,
lat_0=15,
lon_0=95)
elif key == 'euroasia':
kwargs.update(projection='lcc',
resolution='l',
llcrnrlat=-5,
urcrnrlat=45,
llcrnrlon=60,
urcrnrlon=200,
lat_0=42.5,
lon_0=100)
elif key == 'europe':
kwargs.update(projection='lcc',
resolution='l',
llcrnrlat=-5,
urcrnrlat=45,
llcrnrlon=0,
urcrnrlon=140,
lat_0=42.5,
lon_0=40)
elif key == 'northamerica':
kwargs.update(projection='lcc',
resolution='l',
llcrnrlat=-5,
urcrnrlat=45,
llcrnrlon=220,
urcrnrlon=359,
lat_0=42.5,
lon_0=260)
elif key == 'northpolar':
kwargs.update(projection='npaeqd',
resolution='l',
boundinglat=15,
lon_0=105,
round=False)
if 'georange' in kwargs:
georange = kwargs.pop('georange')
kwargs.update(llcrnrlat=georange[0],
urcrnrlat=georange[1],
llcrnrlon=georange[2],
urcrnrlon=georange[3])
kwargs.update(ax=self.ax, projection=projection, resolution=resolution)
if projection == 'cyl':
if 'fix_aspect' not in kwargs:
kwargs.update(fix_aspect=True)
self.trans = False
else:
self.trans = True
self.m = Basemap(**kwargs)
self.ax = plt.gca()
def usemap(self, m):
self.m = m
if self.m.projection != 'cyl':
self.trans = True
else:
self.trans = False
def style(self, s):
if s == 'jma':
self.m.drawmapboundary(fill_color='#87A9D2', ax=self.ax)
self.m.fillcontinents(color='#AAAAAA',
lake_color='#87A9D2',
ax=self.ax)
self.linecolor.update(
dict(coastline='#666666',
country='#666666',
parameri='#666666',
province='#888888',
city='#888888'))
elif s == 'bom':
self.m.drawmapboundary(fill_color='#E6E6FF')
self.m.fillcontinents(color='#E8E1C4', lake_color='#E6E6FF')
self.linecolor.update(
dict(coastline='#D0A85E',
country='#D0A85E',
parameri='#D0A85E',
province='#D0A85E',
city='#D0A85E'))
def drawcoastline(self, lw=0.3, color=None):
if color is None:
color = self.linecolor['coastline']
self.m.drawcoastlines(linewidth=lw, color=color, ax=self.ax)
def drawcountries(self, lw=0.3, color=None):
if color is None:
color = self.linecolor['country']
self.m.drawcountries(linewidth=lw, color=color, ax=self.ax)
def drawprovinces(self, lw=0.2, color=None):
if color is None:
color = self.linecolor['province']
self.m.readshapefile(_ProvinceDirectory,
'Province',
linewidth=lw,
color=color,
ax=self.ax)
def drawcities(self, lw=0.1, color=None):
if color is None:
color = self.linecolor['city']
self.m.readshapefile(_CityDirectory,
'City',
linewidth=lw,
color=color,
ax=self.ax)
self.m.readshapefile(_CitySDirectory,
'CityS',
linewidth=lw,
color=color,
ax=self.ax)
def drawcounties(self, lw=0.1, color=None):
if color is None:
color = self.linecolor['county']
self.m.readshapefile(_CountyDirectory,
'County',
linewidth=lw,
color=color,
ax=self.ax)
def drawparameri(self,
line=None,
color=None,
lw=0.3,
fontsize=None,
**kwargs):
if line is None and not self.trans:
lw = 0
if fontsize is None:
fontsize = self.fontsize['parameri']
if color is None:
color = self.linecolor['parameri']
kwargs.update(linewidth=lw,
fontsize=fontsize,
color=color,
family=self.family)
self.m.drawparallels(np.arange(-80, 80, self.mpstep),
labels=[1, 0, 0, 0],
ax=self.ax,
**kwargs)
self.m.drawmeridians(np.arange(0, 360, self.mpstep),
labels=[0, 0, 0, 1],
ax=self.ax,
**kwargs)
def draw(self, cmd):
if ' ' in cmd:
for c in cmd.split():
self.draw(c)
else:
if cmd == 'coastline' or cmd == 'coastlines':
self.drawcoastline()
elif cmd == 'country' or cmd == 'countries':
self.drawcountries()
elif cmd == 'province' or cmd == 'provinces':
self.drawprovinces()
elif cmd == 'city' or cmd == 'cities':
self.drawcities()
elif cmd == 'county' or cmd == 'counties':
self.drawcounties()
elif cmd == 'parameri' or cmd == 'meripara':
self.drawparameri()
else:
print('Illegal draw command: %s' % (cmd))
def interpolation(self, data, ip=1):
if ip <= 1:
return self.x, self.y, data
else:
nx = np.arange(self.lonmin, self.lonmax + self.res / ip,
self.res / ip)
ny = np.arange(self.latmin, self.latmax + self.res / ip,
self.res / ip)
newx, newy = np.meshgrid(nx, ny)
if self.trans:
nx, ny = self.m(newx, newy)
ndata = interp(data, self.x, self.y, newx, newy, order=3)
return nx, ny, ndata
def stepcal(self, num, ip=1):
totalpt = (self.lonmax - self.lonmin) / self.res * ip
return int(totalpt / num)
def legend(self, lw=0., **kwargs):
rc = dict(loc='upper right', framealpha=0.)
rc.update(kwargs)
ret = self.ax.legend(prop=dict(size=self.fontsize['legend'],
family=self.family),
**rc)
ret.get_frame().set_linewidth(lw)
return ret
def plot(self, *args, **kwargs):
ret = self.ax.plot(*args, **kwargs)
return ret
def scatter(self, *args, **kwargs):
ret = self.ax.scatter(*args, **kwargs)
return ret
def contour(self,
data,
clabel=True,
clabeldict=dict(),
ip=1,
color='k',
lw=0.5,
filter=None,
vline=None,
vlinedict=dict(),
**kwargs):
x, y, data = self.interpolation(data, ip)
kwargs.update(colors=color, linewidths=lw)
c = self.ax.contour(x, y, data, **kwargs)
if vline:
vlinedict = merge_dict(vlinedict, {'color': color, 'lw': lw})
if isinstance(vline, (int, float)):
vline = [vline]
for v in vline:
if not isinstance(v, (int, float)):
raise ValueError('`{}` should be int or float'.format(v))
try:
index = list(c.levels).index(v)
except ValueError:
raise ValueError('{} not in contour levels'.format(v))
else:
c.collections[index].set(**vlinedict)
if clabel:
if 'levels' in clabeldict:
clabellevels = clabeldict.pop('levels')
else:
clabellevels = kwargs['levels']
merge_dict(clabeldict, {
'fmt': '%d',
'fontsize': self.fontsize['clabel']
})
labels = self.ax.clabel(c, **clabeldict)
for l in labels:
l.set_family(self.family)
if vline:
text = l.get_text()
for v in vline:
if str(v) == text:
l.set_color(vlinedict['color'])
if filter is not None:
self.maxminfilter(data, res=self.res / ip, **filter)
return c
def contourf(self,
data,
gpfcmap=None,
cbar=False,
cbardict=dict(),
ip=1,
vline=None,
vlinedict=dict(),
**kwargs):
if gpfcmap:
kwargs = merge_dict(kwargs, gpf.cmap(gpfcmap))
x, y, data = self.interpolation(data, ip)
c = self.ax.contourf(x, y, data, **kwargs)
if cbar:
if 'ticks' not in cbardict:
levels = kwargs['levels']
step = len(levels) // 40 + 1
cbardict.update(ticks=levels[::step])
if 'extend' in kwargs:
cbardict.update(extend=kwargs.pop('extend'), extendfrac=0.02)
self.colorbar(c, unit=kwargs.pop('unit', None), **cbardict)
if vline is not None:
if 'color' not in vlinedict:
vlinedict.update(colors='w')
if 'lw' not in vlinedict:
vlinedict.update(linewidths=0.6)
else:
vlinedict.update(linewidths=vlinedict.pop('lw'))
self.ax.contour(x, y, data, levels=[vline], **vlinedict)
return c
def colorbar(self, mappable, unit=None, **kwargs):
kwargs.update(size='2%', pad='1%')
if kwargs.pop('sidebar', False):
return self.sidebar(mappable, unit, **kwargs)
if kwargs.pop('orientation', None) == 'horizontal':
cb = self.m.colorbar(mappable, 'bottom', **kwargs)
else:
cb = self.m.colorbar(mappable, **kwargs)
self._colorbar_unit(unit)
cb.ax.tick_params(labelsize=self.fontsize['cbar'], length=1.5)
cb.outline.set_linewidth(0.3)
for l in cb.ax.yaxis.get_ticklabels():
l.set_family(self.family)
return cb
def sidebar(self, mappable, unit=None, **kwargs):
ticks = kwargs.pop('ticks')
ticks = [ticks[0], ticks[-1]]
del kwargs['size'], kwargs['pad']
cax = self.fig.add_axes([0.18, 0.13, 0.01, 0.05])
cb = self.fig.colorbar(mappable, cax=cax, ticks=ticks, **kwargs)
cb.ax.tick_params(labelsize=self.fontsize['cbar'], length=0)
cb.outline.set_linewidth(0.1)
for l in cb.ax.yaxis.get_ticklabels():
l.set_family(self.family)
plt.sca(self.ax)
return cb
def streamplot(self, u, v, color='w', lw=0.3, density=2, **kwargs):
kwargs.update(color=color, linewidth=lw, density=density)
ret = self.ax.streamplot(self.x, self.y, u, v, **kwargs)
return ret
def barbs(self, u, v, color='k', lw=0.5, length=4, num=12, **kwargs):
kwargs.update(color=color, linewidth=lw, length=length)
bs = self.stepcal(num)
xbs, ybs, ubs, vbs = self.x[::bs], self.y[::bs], u[::bs, ::
bs], v[::bs, ::bs]
nh = np.meshgrid(xbs, ybs)[1] >= 0
unh = np.ma.masked_where(~nh, ubs)
vnh = np.ma.masked_where(~nh, vbs)
ret = self.ax.barbs(xbs, ybs, unh, vnh, **kwargs)
ush = np.ma.masked_where(nh, ubs)
vsh = np.ma.masked_where(nh, vbs)
retsh = self.ax.barbs(xbs, ybs, ush, vsh, flip_barb=True, **kwargs)
return ret, retsh
def quiver(self,
u,
v,
num=40,
scale=None,
qkey=False,
qkeydict=dict(),
**kwargs):
kwargs.update(width=0.0015, headwidth=3)
if self.trans:
if scale is None:
scale = 500
kwargs.update(scale=scale)
if self.lonmin < 180 < self.lonmax:
u, nx = shiftgrid(180., u, self.nx, start=False)
v, nx = shiftgrid(180., v, self.nx, start=False)
else:
nx = self.nx
uproj, vproj, xx, yy = self.m.transform_vector(u,
v,
nx,
self.ny,
num,
num,
returnxy=True)
q = self.m.quiver(xx, yy, uproj, vproj, **kwargs)
else:
if scale is None:
scale = 500
kwargs.update(scale=scale)
vs = self.stepcal(num)
q = self.m.quiver(self.x[::vs], self.y[::vs], u[::vs, ::vs],
v[::vs, ::vs], **kwargs)
if qkey:
if 'x' in qkeydict and 'y' in qkeydict:
x = qkeydict.pop('x')
y = qkeydict.pop('y')
else:
x, y = 0.5, 1.01
unit = 'm/s' if 'unit' not in qkeydict else qkeydict.pop('unit')
self.ax.quiverkey(q,
x,
y,
scale,
'%d%s' % (scale, unit),
labelpos='W',
fontproperties=dict(family=self.family, size=8))
return q
def pcolormesh(self,
data,
gpfcmap=None,
cbar=False,
cbardict=dict(),
ip=1,
**kwargs):
if gpfcmap:
import matplotlib.colors as mclr
gpfdict = gpf.cmap(gpfcmap)
cmap = gpfdict.pop('cmap')
levels = gpfdict.pop('levels')
norm = mclr.BoundaryNorm(levels, ncolors=cmap.N, clip=True)
kwargs.update(cmap=cmap, norm=norm)
x, y, data = self.interpolation(data, ip)
ret = self.ax.pcolormesh(x, y, data, **kwargs)
if cbar:
if 'ticks' not in cbardict:
levels = gpfdict['levels']
step = len(levels) // 40 + 1
cbardict.update(ticks=levels[::step])
cbardict.update(size='2%', pad='1%')
if 'extend' in gpfdict:
cbardict.update(extend=gpfdict.pop('extend'), extendfrac=0.02)
self.colorbar(ret, unit=gpfdict.pop('unit', None), **cbardict)
return ret
def gridvalue(self,
data,
num=20,
fmt='%d',
color='b',
fontsize=None,
stroke=False,
**kwargs):
if fontsize is None:
fontsize = self.fontsize['gridvalue']
if stroke:
kwargs.update(path_effects=self._get_stroke_patheffects())
#import matplotlib.patheffects as mpatheffects
#kwargs.update(path_effects=[mpatheffects.withSimplePatchShadow(
# offset=(0.5,-0.5), alpha=0.7)])
step = self.stepcal(num)
kwargs.update(color=color,
fontsize=fontsize,
ha='center',
va='center',
family=self.family)
meri, para = len(self.y), len(self.x)
for i in range(1, meri - 1, step):
for j in range(1, para - 1, step):
self.ax.text(j * self.res + self.lonmin,
i * self.res + self.latmin, fmt % (data[i][j]),
**kwargs)
def marktext(self,
x,
y,
text='',
mark='×',
textpos='right',
stroke=False,
bbox=dict(),
family='plotplus',
markfontsize=None,
**kwargs):
if family == 'plotplus':
kwargs.update(family=self.family)
elif family is not None:
kwargs.update(family=family)
if not markfontsize:
markfontsize = self.fontsize['mmfilter']
fontsize = kwargs.pop('fontsize', self.fontsize['marktext'])
if stroke:
kwargs.update(path_effects=self._get_stroke_patheffects())
bbox = merge_dict(bbox, {'facecolor': 'none', 'edgecolor': 'none'})
xy, xytext, ha, va = dict(right=((1, 0.5), (2, 0), 'left', 'center'),
left=((0, 0.5), (-2, 0), 'right', 'center'),
top=((0.5, 1), (0, 1), 'center', 'bottom'),
bottom=((0.5, 0), (0, -1), 'center',
'top')).get(textpos)
an_mark = self.ax.annotate(mark,
xy=(x, y),
xycoords='data',
va='center',
ha='center',
bbox=bbox,
fontsize=markfontsize,
**kwargs)
an_text = self.ax.annotate(text,
xy=xy,
xycoords=an_mark,
xytext=xytext,
textcoords='offset points',
va=va,
ha=ha,
bbox=bbox,
fontsize=fontsize,
**kwargs)
return an_text
def maxminfilter(self,
data,
type='min',
fmt='%d',
weight='bold',
color='b',
fontsize=None,
window=15,
vmin=-1e7,
vmax=1e7,
stroke=False,
marktext=False,
marktextdict=dict(),
**kwargs):
'''Use res keyword or ip keyword to interpolate'''
if fontsize is None:
fontsize = self.fontsize['mmfilter']
if stroke:
kwargs.update(path_effects=self._get_stroke_patheffects())
textfunc = self.ax.text
kwargs.update(fontweight=weight,
color=color,
fontsize=fontsize,
ha='center',
va='center')
if marktext:
argsdict = dict(fontsize=fontsize,
weight=weight,
color=color,
stroke=stroke,
markfontsize=8,
family=None,
textpos='bottom')
kwargs = merge_dict(marktextdict, argsdict)
textfunc = self.marktext
if 'res' in kwargs:
res = kwargs.pop('res')
elif 'ip' in kwargs:
ip = kwargs.pop('ip')
x, y, data = self.interpolation(data, ip)
res = self.res / ip
else:
res = self.res
if type == 'min':
ftr = minimum_filter
elif type == 'max':
ftr = maximum_filter
else:
raise PlotError('Unsupported filter type!')
dataftr = ftr(data, window, mode='reflect')
yind, xind = np.where(data == dataftr)
ymax, xmax = data.shape
for y, x in zip(yind, xind):
d = data[y, x]
if d < vmax and d > vmin and x not in (0, xmax - 1) and y not in (
0, ymax - 1):
textfunc(x * res + self.lonmin, y * res + self.latmin, fmt % d,
**kwargs)
def _get_stroke_patheffects(self):
import matplotlib.patheffects as mpatheffects
return [
mpatheffects.Stroke(linewidth=1, foreground='w'),
mpatheffects.Normal()
]
def title(self, s, nasdaq=True):
if nasdaq:
s = s + ' @NASDAQ'
self.ax.text(0,
1.04,
s,
transform=self.ax.transAxes,
fontsize=self.fontsize['title'],
family=self.family)
def timestamp(self, basetime, fcsthour, duration=0, nearest=None):
stdfmt = '%Y/%m/%d %a %HZ'
if isinstance(basetime, str):
basetime = datetime.strptime(basetime, '%Y%m%d%H')
if duration:
if duration > 0:
fcsthour = fcsthour, fcsthour + duration
else:
fcsthour = fcsthour + duration, fcsthour
elif nearest:
validtime = basetime + timedelta(hours=fcsthour - 1)
nearesttime = validtime.replace(hour=validtime.hour // nearest *
nearest)
fcsthour = fcsthour + nearesttime.hour - validtime.hour - 1, fcsthour
if isinstance(fcsthour, int):
validtime = basetime + timedelta(hours=fcsthour)
s = '%s [+%dh] valid at %s' % (basetime.strftime(stdfmt), fcsthour,
validtime.strftime(stdfmt))
elif isinstance(fcsthour, str):
if fcsthour == 'an':
s = basetime.strftime(stdfmt)
else:
s = ''
else:
fcsthour = tuple(fcsthour)
fromhour, tohour = fcsthour
fromtime = basetime + timedelta(hours=fromhour)
totime = basetime + timedelta(hours=tohour)
s = '%s [+%d~%dh] valid from %s to %s' % (
basetime.strftime(stdfmt), fromhour, tohour,
fromtime.strftime(stdfmt), totime.strftime(stdfmt))
self._timestamp(s)
def _timestamp(self, s):
self.ax.text(0,
1.01,
s,
transform=self.ax.transAxes,
fontsize=self.fontsize['timestamp'],
family=self.family)
def _colorbar_unit(self, s):
if s:
self.ax.text(1.05,
1.01,
s,
transform=self.ax.transAxes,
ha='right',
fontsize=self.fontsize['timestamp'],
family=self.family)
def maxminnote(self, data, name, unit, type='max', fmt='%.1f'):
type = type.lower()
if type == 'max':
typestr = 'Max.'
notevalue = np.amax(data)
elif type == 'min':
typestr = 'Min.'
notevalue = np.amin(data)
elif type == 'mean':
typestr = 'Mean'
notevalue = np.mean(data)
else:
raise PlotError('Unsupported type!')
notestr = '%s %s: ' % (typestr, name) + fmt % notevalue + ' ' + unit
if self.mmnote != '':
self.mmnote = self.mmnote + ' | ' + notestr
else:
self.mmnote = notestr
def _maxminnote(self, s):
self.mmnote = s
def stdsave(self, directory, basetime, fcsthour, imcode):
if isinstance(basetime, str):
basetime = datetime.strptime(basetime, '%Y%m%d%H')
path = os.path.join(directory, '%s_%s_%d_%d%d%d%d.png' % \
(basetime.strftime('%Y%m%d%H'), imcode, fcsthour, self.latmin,
self.latmax, self.lonmin, self.lonmax))
self.save(path)
def save(self, path):
self.ax.text(1,
1.01,
self.mmnote,
ha='right',
transform=self.ax.transAxes,
fontsize=self.fontsize['mmnote'],
family=self.family)
self.ax.axis('off')
self.fig.savefig(path,
dpi=self.dpi,
bbox_inches='tight',
edgecolor='none',
pad_inches=0.08)
nlcs = get_lcs(nftle, .5)
nlcs = nlcs[imin:imax+1, jmin:jmax+1]
(pftle, nx, ny) = read('ftle_pos_' + t_str + '.txt')
plcs = get_lcs(pftle, .5)
plcs = plcs[imin:imax+1, jmin:jmax+1]
# velocity field
if (plot_type == 'velocity'):
ufilename = "u_" + t_str + ".ascii"
vfilename = "v_" + t_str + ".ascii"
u = read_vel(ufilename)
v = read_vel(vfilename)
(ux, uy) = u.shape
lons = np.linspace(m_left_lon, m_right_lon, ux)
lats = np.linspace(m_down_lat, m_up_lat, uy)
xx, yy = m.transform_vector(u.transpose(),v.transpose(),lons,lats,mx,my)
#xp, yp, xq, yq = m.transform_vector(u.transpose(), \
# v.transpose(),lons,lats,int(ux/2),int(uy/2),returnxy=True)
im = m.imshow(np.sqrt(np.square(xx)+np.square(yy)),plt.cm.Blues_r)
im.set_clim(vmin=0,vmax=1.7)
cb = m.colorbar(im, "right", size='5%', pad='2%')
cb.set_label('m/s')
#m.quiver(xq, yq, xp, yp, scale=50)
elif (plot_type == 'vorticity'):
ofilename = "data/omega_" + t_str + ".ascii"
omega = read_vel(ofilename)
(ux, uy) = omega.shape
lons = np.linspace(m_left_lon, m_right_lon, ux)
lats = np.linspace(m_down_lat, m_up_lat, uy)
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
m = Basemap(projection='mill',
llcrnrlat=lat.min(),
urcrnrlat=lat.max(),
llcrnrlon=lon.min(),
urcrnrlon=lon.max(),
resolution='l')
x, y = m(lon, lat)
nice_cmap = plt.get_cmap('RdYlGn')
skip = (slice(None, None, 5), slice(None, None, 5))
ua, va, xv, yv = m.transform_vector(g_uu,
g_vv,
lon1,
lat1,
lon1.shape[0],
lon1.shape[0],
returnxy=True)
m.barbs(xv[skip],
yv[skip],
ua[skip],
va[skip],
cmap=nice_cmap,
length=5,
sizes=dict(emptybarb=0.25, spacing=0.05, height=0.5),
barbcolor='b',
flagcolor='r')
# ,barbcolor='r',linewidth=0.5)
x, y = m(X, Y)
if diagnostic == 1:
# Plot temperature and wind at either the upper or lower level
putstuffhere = 1
else:
# Plot geostrophic vorticity and wind at either the upper or lower level
CS1 = m.contourf(x,y,var_upper,cmap=plt.cm.hot_r,levels=cflevs_upper, extend='both',zorder=1)
cbar = plt.colorbar(CS1, shrink=0.95, orientation='horizontal',extend='both')
CS2 = m.contour(x, y, var_upper, cflevs_upper, colors='k', linewidths=0.5)
cbar.set_ticks(cflevs_upper_ticks)
clabs = ['%i K' % f for f in cflevs_upper_ticks]
cbar.ax.set_yticklabels(clabs, size=10)
if plot_barbs == "true":
# Rotate and interpolate wind from lat/lon grid to map projection grid.
uproj_lower,vproj_lower, xx_lower, yy_lower = m.transform_vector(ugrid_lower,vgrid_lower,newlons,lats,41,41,returnxy=True)
uproj_upper,vproj_upper, xx_upper, yy_upper = m.transform_vector(ugrid_upper,vgrid_upper,newlons,lats,41,41,returnxy=True)
uproj_mid,vproj_mid, xx_mid, yy_mid = m.transform_vector(ugrid_mid,vgrid_mid,newlons,lats,41,41,returnxy=True)
barbs = m.barbs(xx_upper,yy_upper,uproj_upper,vproj_upper,length=5,barbcolor='k',flagcolor='r',linewidth=1.0)
ax1.set_title(titletext1)
save_name = figname + "_01.png"
plt.savefig(save_name, bbox_inches='tight')
# Figure 2
fig = plt.figure(figsize=(8., 16./golden), dpi=128) # New figure
ax1 = fig.add_axes([0.1, 0.1, 0.8, 0.8])
if map_projection == 'ortho':
m = Basemap(projection='ortho', lat_0 = 50, lon_0 = 260,
resolution = 'l', area_thresh = 1000.,ax=ax1)
elif map_projection == 'lcc':
# m = Basemap(llcrnrlon=-125.5,llcrnrlat=15.,urcrnrlon=-30.,urcrnrlat=50.352,\
var_upper,
cmap=plt.cm.hot_r,
levels=cflevs_upper,
extend='both',
zorder=1)
cbar = plt.colorbar(CS1,
shrink=0.95,
orientation='horizontal',
extend='both')
CS2 = m.contour(x, y, var_upper, cflevs_upper, colors='k', linewidths=0.5)
cbar.set_ticks(cflevs_upper_ticks)
clabs = ['%i K' % f for f in cflevs_upper_ticks]
cbar.ax.set_yticklabels(clabs, size=10)
if plot_barbs == "true":
# Rotate and interpolate wind from lat/lon grid to map projection grid.
uproj_lower, vproj_lower, xx_lower, yy_lower = m.transform_vector(
ugrid_lower, vgrid_lower, newlons, lats, 41, 41, returnxy=True)
uproj_upper, vproj_upper, xx_upper, yy_upper = m.transform_vector(
ugrid_upper, vgrid_upper, newlons, lats, 41, 41, returnxy=True)
uproj_mid, vproj_mid, xx_mid, yy_mid = m.transform_vector(ugrid_mid,
vgrid_mid,
newlons,
lats,
41,
41,
returnxy=True)
barbs = m.barbs(xx_upper,
yy_upper,
uproj_upper,
vproj_upper,
length=5,
barbcolor='k',
#-- create map
map = Basemap(projection='cyl',llcrnrlat= -90.,urcrnrlat= 90.,\
resolution='c', llcrnrlon=-180.,urcrnrlon=180.)
#-- draw coastlines, state and country boundaries, edge of map
map.drawcoastlines()
map.drawstates()
map.drawcountries()
#-- create and draw meridians and parallels grid lines
map.drawparallels(np.arange( -90., 90.,30.),labels=[1,0,0,0],fontsize=10)
map.drawmeridians(np.arange(-180.,180.,30.),labels=[0,0,0,1],fontsize=10)
#-- convert latitude/longitude values to plot x/y values
x, y = map(*np.meshgrid(lon,lat))
#-- transform vector and coordinate data
veclon = u10.shape[1]/2 #-- only every 2nd vector
veclat = u10.shape[0]/2 #-- only every 2nd vector
uproj,vproj,xx,yy = map.transform_vector(u,v,lonsout,lat,veclon,veclat,returnxy=True,masked=True)
#-- create vector plot on map
vecplot = map.quiver(xx,yy,uproj,vproj,scale=600)
qk = plt.quiverkey(vecplot, 0.2, -0.2, 20, '20 m/s', labelpos='W') #-- position and reference label
#-- add plot title
plt.title('Wind velocity')
plt.show()
#plt.savefig('plot_vector_matplotlib.png')
from osgeo import gdal
import numpy as np
map = Basemap(projection='sinu',
lat_0=0, lon_0=0)
lons = np.linspace(-180, 180, 8)
lats = np.linspace(-90, 90, 8)
v10 = np.ones((lons.shape)) * 15
u10 = np.zeros((lons.shape))
u10, v10 = np.meshgrid(u10, v10)
u10_rot, v10_rot, x_rot, y_rot = map.transform_vector(u10, v10,
lons, lats,
15, 15,
returnxy=True)
map.drawmapboundary(fill_color='#9999FF')
map.fillcontinents(color='#ddaa66', lake_color='#9999FF', zorder = 0)
map.drawcoastlines(color = '0.15')
#Drawing the original points
lons, lats = np.meshgrid(lons, lats)
x, y = map(lons, lats)
map.barbs(x, y, u10, v10,
pivot='middle', barbcolor='#333333')
#Drawing the rotated & interpolated points
map.barbs(x_rot, y_rot, u10_rot, v10_rot,
pivot='middle', barbcolor='#ff5555')
m=Basemap(projection='merc',lat_ts=10, llcrnrlon=lons.min(),urcrnrlon=lons.max()-3, llcrnrlat=lats.min()+3,urcrnrlat=lats.max(), resolution='c')
fig1 = plt.figure(figsize=(8,10)) ; ax = fig1.add_axes([0.1,0.1,0.8,0.8])
x, y = m(lon, lat)
cmap = plt.cm.Reds
cmap = plt.cm.Spectral
cmap = plt.cm.RdBu_r
clevs = np.arange(990,1010,1)
cs1 = m.contour(x,y,p,clevs,linewidths=1.0,colors='k',animated=True)
cs2 = m.contourf(x,y,p,clevs,cmap=cmap,animated=True)
ugrid,newlons = shiftgrid(62.,uin,lons,start=True)
vgrid,newlons = shiftgrid(62.,vin,lons,start=True)
uproj,vproj,xx,yy = m.transform_vector(ugrid,vgrid,newlons,lats,51,51,returnxy=True,masked=True)
Q = m.quiver(xx,yy,uproj,vproj,scale=250,zorder=10,color='r')
qk = plt.quiverkey(Q, 0.1, 0.1, 20, '15 m/s', labelpos='W',coordinates='data',color='r')
m.readshapefile('subdiv/India_subdiv','ind',drawbounds=True, zorder=None, linewidth=1.0, color='k', antialiased=1, ax=None, default_encoding='utf-8')
m.drawmapboundary(fill_color='aqua') ; #m.fillcontinents(color='white',lake_color='white')
m.drawparallels(np.arange(0.,40.,10.), labels=[1,0,0,0])
m.drawmeridians(np.arange(60.,100.,10.), labels=[0,0,0,1])
cbar=m.colorbar(cs2,location='bottom', pad='5%') ; cbar.set_label('hpa') ;
#plt.clabel(cs2, fontsize=9, inline=1)
m.bluemarble() ;
plt.title('Mean Sea Level Pressure(hpa) & Wind Vectors'); savefig('slp.png', dpi=100);
plt.show()
plt.clf()
m=Basemap(projection='merc',llcrnrlat=20,urcrnrlat=lat[481,401-26]+8,\
llcrnrlon=-90.75,urcrnrlon=lon[481,401-26]+5,lat_ts=20,resolution='f')
# Draw a thick border around the whole map
m.drawmapboundary(linewidth=3)
# Plot Data
xi, yi = m(lon2,lat2)
cs = m.pcolormesh(xi,yi,umag,cmap=cm.gist_ncar_r,vmin=0.005, vmax = 0.1)
xi, yi = m(lon,lat)
cM = m.contour( xi,yi,scope2,[1,1],colors='k',linewidth=2.0)
# transform vectors to projection grid.
uproj,vproj,xx,yy = m.transform_vector(u[1::2,1::2]*10,v[1::2,1::2]*10,\
lonu[0,1::2].squeeze(),latu[1::2,0].squeeze(),\
60,60,returnxy=True,masked=True)
# now plot.
Q = m.quiver(xx,yy,uproj,vproj,scale=15)
# Add Coastlines, States, and Country Boundaries
m.drawcoastlines()
m.drawstates()
m.drawcountries()
m.fillcontinents(color='grey')
# Add Colorbar
clabels=np.array([0.005,0.025,0.05,0.075,0.1])
cbar = m.colorbar(cs, location='right', pad="2%",ticks=clabels,extend='max')
cbar.set_label('Current Speed (m/s)')
cbar.ax.set_yticklabels([0.5,2.5,5,7.5,10])
m = Basemap(width=10000000,
height=10000000,
lon_0=-90,
lat_0=45.,
lat_ts=45,
resolution='l',
projection='stere')
x, y = m(lons, lats)
# transform from spherical to map projection coordinates (rotation
# and interpolation).
nxv = 25
nyv = 25
udat, vdat, xv, yv = m.transform_vector(u,
v,
lons1,
lats1,
nxv,
nyv,
returnxy=True)
# create a figure, add an axes.
fig = plt.figure(figsize=(8, 6))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])
# plot color-filled contours over map
levs = np.arange(960, 1051, 4)
cs1 = m.contour(x, y, p, levs, colors='k', linewidths=0.5)
cs2 = m.contourf(x, y, p, levs)
# plot barbs.
m.barbs(xv,
yv,
udat,
vdat,
fig4.subplots_adjust(right=0.9)
fig4.subplots_adjust(hspace=0.15)
fig4.subplots_adjust(wspace=0.15)
# 10m wind plot
plt.figure(1)
ax1 = plt.subplot(5, 4, nanal)
nx = int((map.xmax - map.xmin) / 50000.) + 1
ny = int((map.ymax - map.ymin) / 50000.) + 1
umean, lons1 = addcyclic(umean, lons1d)
umean, lons2 = shiftgrid(180., umean, lons1, start=False)
vmean, lons1 = addcyclic(vmean, lons1d)
vmean, lons2 = shiftgrid(180., vmean, lons1, start=False)
umean, vmean, x, y = map.transform_vector(umean,
vmean,
lons2,
lats1d,
nx,
ny,
returnxy=True)
spd = np.sqrt(umean**2 + vmean**2)
print spd.shape, spd.min(), spd.max()
map.drawcoastlines(ax=ax1)
map.drawmeridians(np.arange(0, 360, 15),
labels=[0, 0, 0, 1],
yoffset=80000,
fontsize=8,
ax=ax1)
map.drawparallels(np.arange(-90, 90, 10),
labels=[1, 0, 0, 0],
fontsize=8,
ax=ax1)
plt.clabel(cs2,inline=1,fmt='%1.1f',fontsize=12)
# plot wind vectors on projection grid.
# first, shift grid so it goes from -180 to 180 (instead of 0 to 360
# in longitude). Otherwise, interpolation is messed up.
print lat_uwd[0]
lat_rev=lat_uwd[::-1]
print lat_rev[72]
print uwds[iz,0,0]
uwdsx=uwds[iz,::-1,:]
print uwdsx[72,0]
vwdsx=vwds[iz,::-1,:]
ugrid,newlons = shiftgrid(180.,uwdsx,lon_uwd,start=False)
vgrid,newlons = shiftgrid(180.,vwdsx,lon_uwd,start=False)
# transform vectors to projection grid.
uproj,vproj,xx,yy = \
m.transform_vector(ugrid,vgrid,newlons,lat_rev,40,30,returnxy=True,masked=True)
# now plot.
Q = m.quiver(xx,yy,uproj,vproj,color='w')
# make quiver key.
qk = plt.quiverkey(Q, 0.1, 0.1, 10, '10 m/s') #, labelpos='W')
if iz<5:
clevs_ht=[3000.,12000]
color_ht=['lightgrey','lightgrey','lightgrey']
cs3 = m.contourf(x,y,height,clevs_ht, alpha=1.0,\
colors=color_ht,antialiased=True,animated=True)
else:
clevs_ht=[3000.]
color_ht=['lightgrey']
cs3 = m.contour(x,y,height,clevs_ht,linewidths=3.5,\
colors= color_ht,animated=True)
#
if plot_field == 'trth' :
CS1.cmap.set_over('w')
cbar = plt.colorbar(CS1, shrink=0.95, orientation='horizontal',extend='both',pad=0.05)
#clabs = ['%i' % f for f in cflevs_trth]
labels = [item.get_text() for item in cbar.ax.get_xticklabels()]
cbar.ax.set_xticklabels(labels, size=20)
cbar.set_label(cbarlabel,size=20)
if plot_field == 'quivwind' :
ugrid,newlons = shiftgrid(180.,uwind,lons,start=False)
vgrid,newlons = shiftgrid(180.,vwind,lons,start=False)
# transform vectors to projection grid.
uproj,vproj,xx,yy = m.transform_vector(ugrid[::-1,:],vgrid[::-1,:],newlons,lats[::-1],61,61,returnxy=True,masked=True)
# now plot.
Q = m.quiver(xx,yy,uproj,vproj,scale=700,color='g',linewidths=(1,), edgecolors=('g'), headaxislength=2)
if plot_trth_contours == 'True':
CS2 = m.contour(x, y, trth, cflevs_trth_cntrs, colors='k', linewidths=0.25)
if plot_slp == 'True':
CS3 = m.contour(x, y, slp, cflevs_slp, colors='k', linewidths=1.5)
#plt.clabel(CS3, inline=1, fontsize=10, fmt='%i')
plt.clabel(CS3, cflevs_slp, fmt = '%i', inline=True, fontsize=10)
if plot_field == 'ghgt500':
CS3 = m.contour(x, y, plotvar, [contour2plot, contour2plot], colors='green', linewidths=6.0)
def geoplot(data=None, lon=None, lat=None, **kw):
'''Show 2D data in a lon-lat plane.
Parameters
-----------
data: array of shape (n_lat, n_lon), or [u_array, v_array]-like for (u,v)
data or None(default) when only plotting the basemap.
lon: n_lon length vector or None(default).
lat: n_lat length vector or None(default).
kw: dict parameters related to basemap or plot functions.
Basemap related parameters:
----------------------------
basemap_kw: dict parameter in the initialization of a Basemap.
proj or projection: map projection name (default='moll')
popular projections: 'ortho', 'np'(='nplaea'), 'sp'(='splaea')
and other projections given from basemap.
lon_0: map center longitude (None as default).
lat_0: map center latitude (None as default).
lonlatcorner: (llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat).
boundinglat: latitude at the map out boundary (None as default).
basemap_round or round: True(default) or False.
fill_continents: bool value (False as default).
continents_kw: dict parameter used in the Basemap.fillcontinents method.
continents_color: color of continents ('0.33' as default).
lake_color: color of lakes ('none' as default).
ocean_color: color of ocean (None as default).
coastlines_kw: dict parameter used in the Basemap.drawcoastlines method.
coastlines_color: color of coast lines ('0.33' as default).
gridOn: bool value (True as default).
gridLabelOn: bool value (False as default).
parallels_kw: dict parameters used in the Basemap.drawparallels method.
parallels: parallels to be drawn (None as default).
parallels_color: color of parallels ('0.5' as default).
parallels_labels:[0,0,0,0] or [1,0,0,0].
meridians_kw: dict parameters used in the Basemap.drawmeridians method.
meridians: meridians to be drawn (None as default).
meridians_color: color of meridians (parallels_color as default).
meridians_labels: [0,0,0,0] or [0,0,0,1].
lonlatbox: None or (lon_start, lon_end, lat_start, lat_end).
lonlatbox_kw: dict parameters in the plot of lon-lat box.
lonlatbox_color:
General plot parameters:
-------------------------
ax: axis object, default is plt.gca()
plot_type: a string of plot type from ('pcolor', 'pcolormesh', 'imshow', 'contourf', 'contour', 'quiver', 'scatter') or None(default).
cmap: pyplot colormap.
clim: a tuple of colormap limit.
levels: sequence, int or None (default=None)
plot_kw: dict parameters used in the plot functions.
Pcolor/Pcolormesh related parameters:
-------------------------------
rasterized: bool (default is True).
Imshow related parameters
---------------------------
origin: 'lower' or 'upper'.
extent: horizontal range.
interpolation: 'nearest' (default) or 'bilinear' or 'cubic'.
Contourf related parameters:
-------------------------------
extend: 'both'(default).
Contour related parameters:
----------------------------
label_contour: False(default) or True.
Whether to label contours or not.
colors: contour color (default is 'gray').
Quiver plot related parameters:
--------------------------------
stride: stride along lon and lat.
stride_lon: stride along lon.
stride_lat: stride along lat.
quiver_scale: quiver scale.
quiver_color: quiver color.
sparse_polar_grids: bool, default is True.
quiver_kw: dict parameters used in the plt.quiver function.
hide_qkey: bool value, whether to show the quiverkey plot.
qkey_X: X parameter in the plt.quiverkey function (default is 0.85).
qkey_Y: Y parameter in the plt.quiverkey function (default is 1.02).
qkey_U: U parameter in the plt.quiverkey function (default is 2).
qkey_label: label parameter in the plt.quiverkey function.
qkey_labelpos: labelpos parameter in the plt.quiverkey function.
qkey_kw: dict parameters used in the plt.quiverkey function.
Scatter related parameters:
------------------------------
scatter_data: None(default) or (lonvec, latvec).
Hatch plot related parameters:
----------------------------------
hatches: ['///'] is default.
Colorbar related parameters:
-------------------------------
hide_cbar: bool value, whether to show the colorbar.
cbar_type: 'vertical'(shorten as 'v') or 'horizontal' (shorten as 'h').
cbar_extend: extend parameter in the plt.colorbar function.
'neither' as default here.
cbar_size: default '2.5%' for vertical colorbar,
'5%' for horizontal colorbar.
cbar_pad: default 0.1 for vertical colorbar,
0.4 for horizontal colorbar.
cbar_kw: dict parameters used in the plt.colorbar function.
units: str
long_name: str
Returns
--------
basemap object if only basemap is plotted.
plot object if data is shown.
'''
# target axis
ax = kw.pop('ax', None)
if ax is not None:
plt.sca(ax)
if isinstance(data, xr.DataArray):
data_array = data.copy()
data = data_array.values
if np.any(np.isnan(data)):
data = ma.masked_invalid(data)
if lon is None:
try:
lonname = [
s for s in data_array.dims
if s in ('lon', 'longitude', 'X')
][0]
except IndexError:
lonname = [s for s in data_array.dims if 'lon' in s][0]
lon = data_array[lonname]
if lat is None:
try:
latname = [
s for s in data_array.dims if s in ('lat', 'latitude', 'Y')
][0]
except IndexError:
latname = [s for s in data_array.dims if 'lat' in s][0]
lat = data_array[latname]
# guess data name
try:
data_name = data_array.attrs['long_name']
except KeyError:
try:
data_name = data_array.name
except AttributeError:
data_name = ''
# guess data units
try:
data_units = data_array.attrs['units']
except KeyError:
data_units = ''
# copy the original data
elif data is not None:
try:
data = data.copy()
except:
try:
# data has two components(u,v)
data = (data[0].copy(), data[1].copy())
except:
pass
if lon is not None:
lon = lon.copy()
if lat is not None:
lat = lat.copy()
# #### basemap parameters
# basemap kw parameter
basemap_kw = kw.pop('basemap_kw', {})
# projection
# proj = kw.pop('proj', 'cyl')
# proj = kw.pop('proj', 'moll')
proj = kw.pop('proj', 'hammer')
proj = kw.pop('projection',
proj) # projection overrides the proj parameter
# short names for nplaea and splaea projections
if proj in ('npolar', 'polar', 'np'):
proj = 'nplaea'
elif proj in ('spolar', 'sp'):
proj = 'splaea'
# lon_0
lon_0 = kw.pop('lon_0', None)
if lon_0 is None:
if lon is not None:
if np.isclose(np.abs(lon[-1] - lon[0]), 360):
lon_0 = (lon[0] + lon[-2]) / 2.0
else:
lon_0 = (lon[0] + lon[-1]) / 2.0
else:
# dummy = np.linspace(0, 360, data.shape[1]+1)[0:-1]
# lon_0 = ( dummy[0] + dummy[-1] )/2.0
lon_0 = 180
# elif proj in ('moll', 'cyl', 'hammer', 'robin'):
# lon_0 = 180
# elif proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere', 'splaea', 'spaeqd'):
# lon_0 = 0
else: # lon_0 is specified
if lon is not None and proj in ('moll', 'cyl', 'hammer'):
# correct the lon_0 so that it is at the edge of a grid box
lon_0_data = (lon[0] + lon[-1]) / 2.0
d_lon = lon[1] - lon[0]
d_lon_0 = lon_0 - lon_0_data
lon_0 = float(int(d_lon_0 / d_lon)) * d_lon + lon_0_data
# lat_0
lat_0 = kw.pop('lat_0', None)
if lat_0 is None:
if lat is not None:
lat_0 = (lat[0] + lat[-1]) / 2.0
elif proj in ('ortho', ):
lat_0 = 45
# lonlatcorner = (llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat)
lonlatcorner = kw.pop('lonlatcorner', None)
if lonlatcorner is not None:
llcrnrlon = lonlatcorner[0]
urcrnrlon = lonlatcorner[1]
llcrnrlat = lonlatcorner[2]
urcrnrlat = lonlatcorner[3]
else:
llcrnrlon = None
urcrnrlon = None
llcrnrlat = None
urcrnrlat = None
llcrnrlon = basemap_kw.pop('llcrnrlon', llcrnrlon)
urcrnrlon = basemap_kw.pop('urcrnrlon', urcrnrlon)
llcrnrlat = basemap_kw.pop('llcrnrlat', llcrnrlat)
urcrnrlat = basemap_kw.pop('urcrnrlat', urcrnrlat)
if llcrnrlon is None and urcrnrlon is None and llcrnrlat is None and urcrnrlat is None:
lonlatcorner = None
else:
lonlatcorner = (llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat)
# boundinglat
boundinglat = kw.pop('boundinglat', None)
if boundinglat is None:
if proj in ('npstere', 'nplaea', 'npaeqd'):
boundinglat = 30
elif proj in ('spstere', 'splaea', 'spaeqd'):
boundinglat = -30
# basemap round: True or False
if proj in ('npstere', 'nplaea', 'npaeqd', 'spstere', 'splaea', 'spaeqd'):
basemap_round = kw.pop('basemap_round', True)
else:
basemap_round = kw.pop('basemap_round', False)
basemap_round = kw.pop('round', basemap_round)
# base map
proj = basemap_kw.pop('projection', proj)
lon_0 = basemap_kw.pop('lon_0', lon_0)
lat_0 = basemap_kw.pop('lat_0', lat_0)
boundinglat = basemap_kw.pop('boundinglat', boundinglat)
basemap_round = basemap_kw.pop('round', basemap_round)
m = Basemap(projection=proj,
lon_0=lon_0,
lat_0=lat_0,
boundinglat=boundinglat,
round=basemap_round,
llcrnrlon=llcrnrlon,
urcrnrlon=urcrnrlon,
llcrnrlat=llcrnrlat,
urcrnrlat=urcrnrlat,
**basemap_kw)
# fill continents or plot coast lines
fill_continents = kw.pop('fill_continents', False)
if fill_continents:
# use Basemap.fillcontinents method
continents_kw = kw.pop('continents_kw', {})
continents_color = kw.pop('continents_color', '0.33')
continents_color = continents_kw.pop('color', continents_color)
lake_color = kw.pop('lake_color', 'none')
lake_color = continents_kw.pop('lake_color', lake_color)
m.fillcontinents(color=continents_color,
lake_color=lake_color,
**continents_kw)
# else:
draw_coastlines = kw.pop('draw_coastlines', not fill_continents)
if draw_coastlines:
# use Basemap.drawcoastlines method
coastlines_kw = kw.pop('coastlines_kw', {})
coastlines_color = kw.pop('coastlines_color', '0.33')
coastlines_color = coastlines_kw.pop('color', coastlines_color)
coastlines_lw = kw.pop('coastlines_lw', 0.5)
coastlines_lw = coastlines_kw.pop('lw', coastlines_lw)
m.drawcoastlines(color=coastlines_color,
linewidth=coastlines_lw,
**coastlines_kw)
ocean_color = kw.pop('ocean_color', None)
if ocean_color is not None:
m.drawmapboundary(fill_color=ocean_color)
# parallels
gridOn = kw.pop('gridOn', True)
gridLabelOn = kw.pop('gridLabelOn', False)
parallels_kw = kw.pop('parallels_kw', {})
# parallels = kw.pop('parallels', np.arange(-90,91,30))
parallels = kw.pop('parallels', None)
parallels = parallels_kw.pop('parallels', parallels)
parallels_color = kw.pop('parallels_color', '0.5')
parallels_color = parallels_kw.pop('color', parallels_color)
parallels_lw = kw.pop('parallels_lw', 0.5)
parallels_lw = parallels_kw.pop('lw', parallels_lw)
parallels_labels = kw.pop('parallels_labels', None)
parallels_labels = parallels_kw.pop('labels', parallels_labels)
if parallels_labels is None:
if gridLabelOn:
parallels_labels = [1, 0, 0, 0]
else:
parallels_labels = [0, 0, 0, 0]
if parallels is not None:
m.drawparallels(parallels,
color=parallels_color,
labels=parallels_labels,
linewidth=parallels_lw,
**parallels_kw)
elif gridOn:
m.drawparallels(np.arange(-90, 91, 30),
color=parallels_color,
linewidth=parallels_lw,
labels=parallels_labels,
**parallels_kw)
# meridians
meridians_kw = kw.pop('meridians_kw', {})
# meridians = kw.pop('meridians', np.arange(-180, 360, 30))
meridians = kw.pop('meridians', None)
meridians = meridians_kw.pop('meridians', meridians)
meridians_color = kw.pop('meridians_color', parallels_color)
meridians_color = meridians_kw.pop('color', meridians_color)
meridians_lw = kw.pop('meridians_lw', parallels_lw)
meridians_lw = meridians_kw.pop('lw', meridians_lw)
meridians_labels = kw.pop('meridians_labels', None)
meridians_labels = meridians_kw.pop('labels', meridians_labels)
if meridians_labels is None:
if gridLabelOn:
if proj in ('npstere', 'nplaea', 'npaeqd', 'spstere', 'splaea',
'spaeqd'):
meridians_labels = [1, 1, 0, 0]
elif proj in ('cyl', ):
meridians_labels = [0, 0, 0, 1]
else:
meridians_labels = [0, 0, 0, 0]
print('Meridian are not labeled.')
else:
meridians_labels = [0, 0, 0, 0]
if meridians is not None:
m.drawmeridians(meridians,
color=meridians_color,
labels=meridians_labels,
linewidth=meridians_lw,
**meridians_kw)
elif gridOn:
m.drawmeridians(np.arange(0, 360, 30),
color=meridians_color,
labels=meridians_labels,
linewidth=meridians_lw,
**meridians_kw)
# lonlatbox
lonlatbox = kw.pop('lonlatbox', None)
if lonlatbox is not None:
lonlon = np.array([
np.linspace(lonlatbox[0], lonlatbox[1],
100), lonlatbox[1] * np.ones(100),
np.linspace(lonlatbox[1], lonlatbox[0], 100),
lonlatbox[0] * np.ones(100)
]).ravel()
latlat = np.array([
lonlatbox[2] * np.ones(100),
np.linspace(lonlatbox[2], lonlatbox[3], 100),
lonlatbox[3] * np.ones(100),
np.linspace(lonlatbox[3], lonlatbox[2], 100)
]).ravel()
lonlatbox_kw = kw.pop('lonlatbox_kw', {})
lonlatbox_color = kw.pop('lonlatbox_color', 'k')
lonlatbox_color = lonlatbox_kw.pop('color', lonlatbox_color)
m.plot(lonlon,
latlat,
latlon=True,
color=lonlatbox_color,
**lonlatbox_kw)
# scatter
scatter_data = kw.pop('scatter_data', None)
if scatter_data is not None:
# L = data.astype('bool')
# marker_color = kw.pop('marker_color', 'k')
# plot_obj = m.scatter(X[L], Y[L], color=marker_color, **kw)
lonvec, latvec = scatter_data
plot_obj = m.scatter(lonvec, latvec, **kw)
# #### stop here and return the map object if data is None
if data is None:
return m
# data prepare
input_data_have_two_components = isinstance(data, tuple) \
or isinstance(data, list)
if input_data_have_two_components:
# input data is (u,v) or [u, v] where u, v are ndarray and two components of a vector
assert len(
data) == 2, 'quiver data must contain only two componets u and v'
u = data[0].squeeze()
v = data[1].squeeze()
assert u.ndim == 2, 'u component data must be two dimensional'
assert v.ndim == 2, 'v component data must be two dimensional'
data = np.sqrt(u**2 + v**2) # calculate wind speed
else: # input data is a ndarray
data = data.squeeze()
assert data.ndim == 2, 'Input data must be two dimensional!'
# lon
if lon is None:
# lon = np.linspace(0, 360, data.shape[1]+1)[0:-1]
# lon_edge = np.hstack((
# lon[0]*2 - lon[1],
# lon,
# lon[-1]*2 - lon[-2]))
# lon_edge = ( lon_edge[:-1] + lon_edge[1:] )/2.0
lon_edge = np.linspace(lon_0 - 180, lon_0 + 180, data.shape[1] + 1)
lon = (lon_edge[:-1] + lon_edge[1:]) / 2.0
else: # lon is specified
if np.isclose(np.abs(lon[-1] - lon[0]), 360):
# first and last longitude point to the same location: remove the last longitude
lon = lon[:-1]
data = data[:, :-1]
if input_data_have_two_components:
u = u[:, :-1]
v = v[:, :-1]
if (not np.isclose(lon_0, (lon[0] + lon[-1]) / 2.0)
and proj in ('moll', 'cyl', 'hammer', 'robin')):
# lon_0 not at the center of lon, need to shift grid
lon_west_end = lon_0 - 180 + (
lon[1] - lon[0]) / 2.0 # longitude of west end
# make sure the longitude of west end within the lon
if lon_west_end < lon[0]:
lon_west_end += 360
elif lon_west_end > lon[-1]:
lon_west_end -= 360
data, lon_shift = shiftgrid(lon_west_end, data, lon, start=True)
if input_data_have_two_components:
u, lon_shift = shiftgrid(lon_west_end, u, lon, start=True)
v, lon_shift = shiftgrid(lon_west_end, v, lon, start=True)
lon = lon_shift
if lon[0] < -180:
lon += 360
elif lon[-1] >= 540:
lon -= 360
lon_hstack = np.hstack(
(2 * lon[0] - lon[1], lon, 2 * lon[-1] - lon[-2]))
lon_edge = (lon_hstack[:-1] + lon_hstack[1:]) / 2.0
# lat
if lat is None:
lat_edge = np.linspace(-90, 90, data.shape[0] + 1)
lat = (lat_edge[:-1] + lat_edge[1:]) / 2.0
else:
lat_hstack = np.hstack(
(2 * lat[0] - lat[1], lat, 2 * lat[-1] - lat[-2]))
lat_edge = (lat_hstack[:-1] + lat_hstack[1:]) / 2.0
lat_edge[lat_edge > 90] = 90
lat_edge[lat_edge < -90] = -90
Lon, Lat = np.meshgrid(lon, lat)
X, Y = m(Lon, Lat)
Lon_edge, Lat_edge = np.meshgrid(lon_edge, lat_edge)
X_edge, Y_edge = m(Lon_edge, Lat_edge)
# ###### plot parameters
# plot_type
plot_type = kw.pop('plot_type', None)
if plot_type is None:
if input_data_have_two_components:
plot_type = 'quiver'
# elif ( proj in ('cyl',)
# and lonlatcorner is None
# ):
# plot_type = 'imshow'
# print('plot_type **** imshow **** is used.')
elif proj in ('nplaea', 'splaea', 'ortho'):
# pcolormesh has a problem for these projections
plot_type = 'pcolor'
print('plot_type **** pcolor **** is used.')
else:
plot_type = 'pcolormesh'
print('plot_type **** pcolormesh **** is used.')
# cmap
cmap = kw.pop('cmap', None)
if cmap is None:
zz_max = data.max()
zz_min = data.min()
if zz_min >= 0:
try:
cmap = plt.get_cmap('viridis')
except:
cmap = plt.get_cmap('OrRd')
elif zz_max <= 0:
try:
cmap = plt.get_cmap('viridis')
except:
cmap = plt.get_cmap('Blues_r')
else:
cmap = plt.get_cmap('RdBu_r')
elif isinstance(cmap, str):
cmap = plt.get_cmap(cmap)
# clim parameters
clim = kw.pop('clim', None)
robust = kw.pop('robust', False)
if clim is None:
if isinstance(data, np.ma.core.MaskedArray):
data1d = data.compressed()
else:
data1d = data.ravel()
notNaNs = np.logical_not(np.isnan(data1d))
data1d = data1d[notNaNs]
if robust:
a = np.percentile(data1d, 2)
b = np.percentile(data1d, 98)
else:
a = data1d.min()
b = data1d.max()
if a * b < 0:
b = max(abs(a), abs(b))
a = -b
clim = a, b
# levels
levels = kw.pop('levels', None)
if levels is None:
if plot_type in ('contour', 'contourf', 'contourf+'):
a, b = clim
levels = np.linspace(a, b, 11)
elif isinstance(levels, int):
if plot_type in ('contour', 'contourf', 'contourf+'):
a, b = clim
levels = np.linspace(a, b, levels)
elif plot_type in ('pcolor', 'pcolormesh', 'imshow'):
cmap = plt.get_cmap(cmap.name, levels - 1)
else: # levels is a sequence
if plot_type in ('pcolor', 'pcolormesh', 'imshow'):
cmap = plt.get_cmap(cmap.name, len(levels) - 1)
clim = min(levels), max(levels)
# colorbar parameters
if plot_type in ('pcolor', 'pcolormesh', 'contourf', 'contourf+',
'imshow'):
cbar_type = kw.pop('cbar_type', 'vertical')
cbar_kw = kw.pop('cbar_kw', {})
cbar_extend = kw.pop('cbar_extend', 'neither')
cbar_extend = cbar_kw.pop('extend', cbar_extend)
hide_cbar = kw.pop('hide_cbar', False)
if cbar_type in ('v', 'vertical'):
cbar_size = kw.pop('cbar_size', '2.5%')
cbar_size = cbar_kw.pop('size', cbar_size)
cbar_pad = kw.pop('cbar_pad', 0.1)
cbar_pad = cbar_kw.pop('pad', cbar_pad)
cbar_position = 'right'
cbar_orientation = 'vertical'
elif cbar_type in ('h', 'horizontal'):
# cbar = hcolorbar(units=units)
cbar_size = kw.pop('cbar_size', '5%')
cbar_size = cbar_kw.pop('size', cbar_size)
cbar_pad = kw.pop('cbar_pad', 0.4)
cbar_pad = cbar_kw.pop('pad', cbar_pad)
cbar_position = 'bottom'
cbar_orientation = 'horizontal'
# units in colorbar
units = kw.pop('units', None)
if units is None:
try:
units = data_units # input data is a DataArray
except:
units = ''
# long_name in colorbar
long_name = kw.pop('long_name', None)
if long_name is None:
try:
long_name = data_name # if input data is a DataArray
if long_name is None:
long_name = ''
except:
long_name = ''
# ###### plot
# pcolor
if plot_type in ('pcolor', ):
rasterized = kw.pop('rasterized', True)
plot_obj = m.pcolor(X_edge,
Y_edge,
data,
cmap=cmap,
rasterized=rasterized,
**kw)
# pcolormesh
elif plot_type in ('pcolormesh', ):
rasterized = kw.pop('rasterized', True)
plot_obj = m.pcolormesh(X_edge,
Y_edge,
data,
cmap=cmap,
rasterized=rasterized,
**kw)
# imshow
elif plot_type in ('imshow', ):
if Y_edge[-1, 0] > Y_edge[0, 0]:
origin = kw.pop('origin', 'lower')
else:
origin = kw.pop('origin', 'upper')
extent = kw.pop(
'extent',
[X_edge[0, 0], X_edge[0, -1], Y_edge[0, 0], Y_edge[-1, 0]])
interpolation = kw.pop('interpolation', 'nearest')
plot_obj = m.imshow(data,
origin=origin,
cmap=cmap,
extent=extent,
interpolation=interpolation,
**kw)
# contourf
elif plot_type in ('contourf', ):
if proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere',
'splaea', 'spaeqd')\
and np.isclose(np.abs(lon_edge[-1]-lon_edge[0]), 360):
data, lon = addcyclic(data, lon)
Lon, Lat = np.meshgrid(lon, lat)
X, Y = m(Lon, Lat)
extend = kw.pop('extend', 'both')
plot_obj = m.contourf(X,
Y,
data,
extend=extend,
cmap=cmap,
levels=levels,
**kw)
# contour
elif plot_type in ('contour', ):
if proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere',
'splaea', 'spaeqd')\
and np.isclose(np.abs(lon_edge[-1]-lon_edge[0]), 360):
data, lon = addcyclic(data, lon)
Lon, Lat = np.meshgrid(lon, lat)
X, Y = m(Lon, Lat)
colors = kw.pop('colors', 'k')
if colors is not None:
cmap = None
alpha = kw.pop('alpha', 0.5)
plot_obj = m.contour(X,
Y,
data,
cmap=cmap,
colors=colors,
levels=levels,
alpha=alpha,
**kw)
label_contour = kw.pop('label_contour', False)
if label_contour:
plt.clabel(plot_obj, plot_obj.levels[::2], fmt='%.2G')
# contourf + contour
elif plot_type in ('contourf+', ):
if proj in ('ortho','npstere', 'nplaea', 'npaeqd', 'spstere',
'splaea', 'spaeqd')\
and np.isclose(np.abs(lon_edge[-1]-lon_edge[0]), 360):
data, lon = addcyclic(data, lon)
Lon, Lat = np.meshgrid(lon, lat)
X, Y = m(Lon, Lat)
extend = kw.pop('extend', 'both')
linewidths = kw.pop('linewidths', 1)
plot_obj = m.contourf(X,
Y,
data,
extend=extend,
cmap=cmap,
levels=levels,
**kw)
colors = kw.pop('colors', 'k')
if colors is not None:
cmap = None
alpha = kw.pop('alpha', 0.5)
m.contour(X,
Y,
data,
cmap=cmap,
colors=colors,
alpha=alpha,
levels=levels,
linewidths=linewidths,
**kw)
# quiverplot
elif plot_type in ('quiver', ):
nGrids = kw.pop('nGrids', 50)
nx = kw.pop('nx', nGrids)
ny = kw.pop('ny', nGrids)
stride = kw.pop('stride', 1)
stride_lon = kw.pop('stride_lon', stride)
stride_lat = kw.pop('stride_lat', stride)
print(stride, stride_lon, stride_lat)
if (stride != 1) or (stride_lon != 1) or (
stride_lat != 1
): # compatible with old api, with stride, stride_lon, stride_lat controling quiver grids. To be obsolete. Use nGrids, nx, ny instead
print('stride used')
lon_ = lon[::stride_lon] # subset of lon
lat_ = lat[::stride_lat]
u_ = u[::stride_lat, ::stride_lon]
v_ = v[::stride_lat, ::stride_lon]
# sparse polar area
sparse_polar_grids = kw.pop('sparse_polar_grids', True)
if sparse_polar_grids:
msk = np.empty(u_.shape) * np.nan
for i in range(lat_.size):
step = int(1. / np.cos(lat_[i] * np.pi / 180))
msk[i, 0::step] = 0
u_ += msk
v_ += msk
Lon_, Lat_ = np.meshgrid(lon_, lat_)
u_rot, v_rot, X_, Y_ = m.rotate_vector(u_,
v_,
Lon_,
Lat_,
returnxy=True)
else: # use nGrids, nx, ny to control the quiver grids
if lon.max() > 180:
u_, lon_ = shiftgrid(180., u, lon, start=False)
v_, lon_ = shiftgrid(180., v, lon, start=False)
else:
u_ = u
v_ = v
lon_ = lon
u_rot, v_rot, X_, Y_ = m.transform_vector(u_,
v_,
lon_,
lat,
nx,
ny,
returnxy=True)
quiver_color = kw.pop('quiver_color', 'g')
quiver_scale = kw.pop('quiver_scale', None)
hide_qkey = kw.pop('hide_qkey', False)
qkey_kw = kw.pop('qkey_kw', {})
qkey_X = kw.pop('qkey_X', 0.85)
qkey_X = qkey_kw.pop('X', qkey_X)
qkey_Y = kw.pop('qkey_Y', 1.02)
qkey_Y = qkey_kw.pop('Y', qkey_Y)
qkey_U = kw.pop('qkey_U', 2)
qkey_U = qkey_kw.pop('U', qkey_U)
qkey_label = kw.pop('qkey_label', '{:g} '.format(qkey_U) + units)
qkey_label = qkey_kw.pop('label', qkey_label)
qkey_labelpos = kw.pop('qkey_labelpos', 'W')
qkey_labelpos = qkey_kw.pop('labelpos', qkey_labelpos)
plot_obj = m.quiver(X_,
Y_,
u_rot,
v_rot,
color=quiver_color,
scale=quiver_scale,
**kw)
if not hide_qkey:
# quiverkey plot
plt.quiverkey(plot_obj,
qkey_X,
qkey_Y,
qkey_U,
label=qkey_label,
labelpos=qkey_labelpos,
**qkey_kw)
# hatch plot
elif plot_type in ('hatch', 'hatches'):
hatches = kw.pop('hatches', ['///'])
plot_obj = m.contourf(X,
Y,
data,
colors='none',
hatches=hatches,
extend='both',
**kw)
else:
print(
'Please choose a right plot_type from ("pcolor", "contourf", "contour")!'
)
# set clim
if plot_type in ('pcolor', 'pcolormesh', 'imshow'):
plt.clim(clim)
# plot colorbar
if plot_type in ('pcolor', 'pcolormesh', 'contourf', 'contourf+',
'imshow'):
ax_current = plt.gca()
divider = make_axes_locatable(ax_current)
cax = divider.append_axes(cbar_position, size=cbar_size, pad=cbar_pad)
cbar = plt.colorbar(plot_obj,
cax=cax,
extend=cbar_extend,
orientation=cbar_orientation,
**cbar_kw)
if cbar_type in ('v', 'vertical'):
# put the units on the top of the vertical colorbar
cbar.ax.xaxis.set_label_position('top')
cbar.ax.set_xlabel(units)
cbar.ax.set_ylabel(long_name)
elif cbar_type in ('h', 'horizontal'):
# cbar.ax.yaxis.set_label_position('right')
# cbar.ax.set_ylabel(units, rotation=0, ha='left', va='center')
if long_name == '' or units == '':
cbar.ax.set_xlabel('{}{}'.format(long_name, units))
else:
cbar.ax.set_xlabel('{} [{}]'.format(long_name, units))
# remove the colorbar to avoid repeated colorbars
if hide_cbar:
cbar.remove()
# set back the main axes as the current axes
plt.sca(ax_current)
return plot_obj
else:
title.set_text('t = %.4f' % output['t'][0])
vph, newlon = shiftgrid(180.,
output['vph'].T,
np.degrees(lon),
start=False)
vth, newlon = shiftgrid(180.,
output['vth'].T,
np.degrees(lon),
start=False)
uproj, vproj, xx, yy = mp.transform_vector(vph[::-1],
vth[::-1],
newlon,
np.degrees(lat[::-1]),
81,
81,
returnxy=True,
masked=True)
Q = mp.quiver(xx,
yy,
uproj,
vproj,
scale=1000,
pivot='middle',
headwidth=2,
headlength=2,
headaxislength=2)
plt.savefig('images/vector_%05i.png' % i, dpi=300)
def plot_routes(self, results_files, best_inds_files):
fig = plt.figure()
fig.suptitle('Routes', fontsize=12)
r_iter = iter(
[r for ro in range(self.rows) for r in [ro] * self.columns])
c_iter = iter(list(range(self.columns)) * self.rows)
for i, result in enumerate(results_files):
r, c = next(r_iter), next(c_iter)
shortest_paths = result['initialRoutes']
individuals = best_inds_files[i]
ax = plt.subplot2grid((self.rows, self.columns), (r, c))
ax.set_title("{}".format(self.titles[i]), fontsize=10)
m = Basemap(projection='merc',
resolution='c',
llcrnrlat=self.bot,
urcrnrlat=self.top,
llcrnrlon=self.lef,
urcrnrlon=self.rig,
ax=ax)
m.drawparallels(np.arange(-90., 90., 10.),
labels=[1, 0, 0, 0],
fontsize=8)
m.drawmeridians(np.arange(-180., 180., 10.),
labels=[0, 0, 0, 1],
fontsize=8)
m.drawmapboundary(color='black', fill_color='aqua')
m.fillcontinents(color='lightgray',
lake_color='lightgray',
zorder=2)
m.readshapefile(self.DIR /
'data/bathymetry_200m/ne_10m_bathymetry_K_200',
'ne_10m_bathymetry_K_200',
drawbounds=False)
ps = [
patches.Polygon(np.array(shape), True)
for shape in m.ne_10m_bathymetry_K_200
]
ax.add_collection(PatchCollection(ps, facecolor='white', zorder=2))
# Plot initial routes
for p in shortest_paths.values():
for sp in p['path'].values():
for shortest_path in sp.values():
waypoints = [item[0] for item in shortest_path]
edges = zip(waypoints[:-1], waypoints[1:])
for e in edges:
m.drawgreatcircle(e[0][0],
e[0][1],
e[1][0],
e[1][1],
linewidth=2,
color='black',
zorder=3)
# Plot individuals
for p in individuals.values():
for sp in p.values():
for ind in sp:
# Create colors
true_speeds = [item[1] for item in ind[:-1]]
normalized_speeds = [
(speed - min(self.vessel.speeds)) /
(max(self.vessel.speeds) - min(self.vessel.speeds))
for speed in true_speeds
] + [0]
# Plot edges
waypoints = [item[0] for item in ind]
edges = zip(waypoints[:-1], waypoints[1:])
for j, e in enumerate(edges):
m.drawgreatcircle(e[0][0],
e[0][1],
e[1][0],
e[1][1],
linewidth=2,
color=self.col_map(
normalized_speeds[j]),
zorder=3)
for j, (x, y) in enumerate(waypoints):
m.scatter(x,
y,
latlon=True,
color='dimgray',
marker='o',
s=5,
zorder=4)
if self.plot_currents:
# Transform vector and coordinate data
vec_lon = int(self.uin.shape[1] / (2 * 360 /
(self.rig - self.lef)))
vec_lat = int(self.uin.shape[0] / (2 * 180 /
(self.top - self.bot)))
u_rot, v_rot, x, y = m.transform_vector(self.uin,
self.vin,
self.lons,
self.lats,
vec_lon,
vec_lat,
returnxy=True)
vec_plot = m.quiver(x,
y,
u_rot,
v_rot,
color='gray',
scale=50,
width=.002)
plt.quiverkey(vec_plot, 0.2, -0.2, 1, '1 knot',
labelpos='W') # Position and reference label
if self.ecas:
for eca in self.ecas:
lon, lat = eca.exterior.xy
x, y = m(lon, lat)
m.plot(x, y, 'o-', markersize=2, linewidth=1)
if self.show_colorbar:
# Create color bar
sm = plt.cm.ScalarMappable(cmap=self.col_map)
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
col_bar = plt.colorbar(sm,
norm=plt.Normalize(
vmin=min(self.vessel.speeds),
vmax=max(self.vessel.speeds)),
cax=cax)
min_s, max_s = min(self.vessel.speeds), max(self.vessel.speeds)
# noinspection PyProtectedMember
col_bar._ax.set_yticklabels([
'%.1f' % round(min_s, 1),
'%.1f' % round((1 / 5) * (max_s - min_s) + min_s, 1),
'%.1f' % round((2 / 5) * (max_s - min_s) + min_s, 1),
'%.1f' % round((3 / 5) * (max_s - min_s) + min_s, 1),
'%.1f' % round((4 / 5) * (max_s - min_s) + min_s, 1),
'%.1f' % round(max_s, 1)
],
fontsize=8)
col_bar.set_label('Calm water speed [kn]',
rotation=270,
labelpad=15,
fontsize=10)
grid_lons, grid_lats = np.meshgrid(lon, lat)
stereo_x, stereo_y = m(grid_lons, grid_lats)
m.pcolor(stereo_x, stereo_y, np.squeeze(v10[count, :, :]))
pl.savefig('/Users/jmh2g09/Documents/PhD/Data/Wind/Figures/'+ year + month + '_10m_v_wind.png',
format='png')
pl.close()
pl.figure()
pl.clf()
m = Basemap(projection='spstere', boundinglat=-50, lon_0=180, resolution='l')
m.drawmapboundary()
m.drawcoastlines(zorder=10)
#m.fillcontinents(zorder=10)
m.drawparallels(np.arange(-80., 81., 20.), labels=[1, 0, 0, 0])
m.drawmeridians(np.arange(-180., 181., 20.), labels=[0, 0, 0, 1])
ugrid, newlons = shiftgrid(180.,np.squeeze(np.flipud(u10[count, :, :])),lon,start=False)
vgrid, newlons = shiftgrid(180.,np.squeeze(np.flipud(v10[count, :, :])),lon,start=False)
uproj,vproj,xx,yy = m.transform_vector(ugrid,vgrid,newlons,np.flipud(lat),70, 70,returnxy=True,masked=True)
m.quiver(xx, yy, -uproj, -vproj)
pl.savefig('/Users/jmh2g09/Documents/PhD/Data/Wind/Figures/'+ year + month + '_wind_quiver.png',
format='png')
pl.close()
count += 1
map.drawcoastlines(linewidth=2, color="#444444", zorder=6)
map.drawcountries(linewidth=1, color="#444444", zorder=5)
map.drawstates(linewidth=0.66, color="#444444", zorder=4)
map.drawmapboundary
x, y = map(X, Y)
cf = map.contour(x, y, temperature_plot, levels=clevs, extend="both", zorder=1, linewidths=2)
plt.clabel(cf, inline=1, fontsize=10)
# plot wind vectors on projection grid.
# first, shift grid so it goes from -180 to 180 (instead of 0 to 360
# in longitude). Otherwise, interpolation is messed up.
ugrid, newlons = shiftgrid(180.0, u_plot, lons, start=False)
vgrid, newlons = shiftgrid(180.0, v_plot, lons, start=False)
# transform vectors to projection grid and plot windbarbs.
uproj, vproj, xx, yy = map.transform_vector(ugrid, vgrid, newlons, lats, 41, 41, returnxy=True)
barbs = map.barbs(xx, yy, uproj, vproj, length=5, barbcolor="k", flagcolor="r", linewidth=0.5)
# Title
ax1.set_title(str(levelh) + " hPa temperature and wind barbs")
# <codecell>
# Temperature advection plot
cbar_min = -0.0001
cbar_max = 0.0001
cfint = 0.00001
cflevs = np.arange(cbar_min, cbar_max + cfint - (cfint / 2), cfint)
ncolors = np.size(cflevs) - 1
cmap = cm.get_cmap("jet")
djet = cmap_whitezero(cmap, ncolors, 1, -1)
#-- create map
map = Basemap(projection='cyl',llcrnrlat= -90.,urcrnrlat= 90.,\
resolution='c', llcrnrlon=-180.,urcrnrlon=180.)
#-- draw coastlines, state and country boundaries, edge of map
map.drawcoastlines()
map.drawstates()
map.drawcountries()
#-- create and draw meridians and parallels grid lines
map.drawparallels(np.arange( -90., 90.,30.),labels=[1,0,0,0],fontsize=10)
map.drawmeridians(np.arange(-180.,180.,30.),labels=[0,0,0,1],fontsize=10)
#-- convert latitude/longitude values to plot x/y values
x, y = list(map(*np.meshgrid(lon,lat)))
#-- transform vector and coordinate data
veclon = u10.shape[1]/2 #-- only every 2nd vector
veclat = u10.shape[0]/2 #-- only every 2nd vector
uproj,vproj,xx,yy = map.transform_vector(u,v,lonsout,lat,veclon,veclat,returnxy=True,masked=True)
#-- create vector plot on map
vecplot = map.quiver(xx,yy,uproj,vproj,scale=600)
qk = plt.quiverkey(vecplot, 0.2, -0.2, 20, '20 m/s', labelpos='W') #-- position and reference label
#-- add plot title
plt.title('Wind velocity')
plt.show()
#plt.savefig('plot_vector_matplotlib.png')
fig, ax = plt.subplots(figsize=(12, 9))
m.drawcoastlines()
m.drawcountries()
m.fillcontinents(color='white', lake_color='black', zorder=0)
m.drawparallels(np.arange(-10, 10, 5), labels=[1, 0, 1, 1], fontsize=5)
m.drawmeridians(np.arange(100, 115, 5), labels=[1, 1, 0, 1], fontsize=5)
# Quiver Angin
X = np.arange(0, xx.shape[1], 8)
Y = np.arange(0, yy.shape[0], 8)
points = np.meshgrid(Y, X)
lats = lat
u, v, X, Y = m.transform_vector(uu,
vv,
lon,
lats,
31,
21,
returnxy=True,
masked=True)
q = m.quiver(X, Y, u, v, pivot='middle', scale=10, scale_units='inches')
plt.quiverkey(q,
X=0.1,
Y=-0.13,
U=5,
label='Kec = 5 m $s^{-1}$',
labelpos='E',
fontproperties={'size': 8})
plt.show()
# In[58]:
lat_ts=20,
resolution="f",
)
# Draw a think border around the whole map
m.drawmapboundary(linewidth=3)
# Plot Data
xi, yi = m(lon2, lat2)
cs = m.pcolormesh(xi, yi, umag, cmap=cm.gist_ncar_r, vmin=0.01, vmax=1)
xi, yi = m(lon, lat)
cM = m.contour(xi, yi, scope2, [1, 1], colors="k", linewidth=2.0)
# transform vectors to projection grid.
uproj, vproj, xx, yy = m.transform_vector(
u[::3, ::3], v[::3, ::3], lonu[0, ::3].squeeze(), latu[::3, 0].squeeze(), 60, 60, returnxy=True, masked=True
)
# now plot.
Q = m.quiver(xx, yy, uproj, vproj, scale=15)
# Add Grid Lines
m.drawparallels(np.arange(0.0, 90.0, 10.0), labels=[1, 0, 0, 0], fontsize=10, linewidth=0.75, color=".5")
m.drawmeridians(np.arange(-105.0, -35.0, 10.0), labels=[0, 0, 0, 1], fontsize=10, linewidth=0.75, color=".5")
# Add Coastlines, States, and Country Boundaries
m.drawcoastlines()
m.drawstates()
m.drawcountries()
m.fillcontinents(color="grey")
# Add Colorbar
ugrid = grbu.values
vgrid = grbv.values
mslpgrid = 0.01 * grbmslp.values
lats, lons = grbmslp.latlons()
lats1d = lats[:, 0]
lons1d = lons[0, :]
nx = int((map.xmax - map.xmin) / 50000.) + 1
ny = int((map.ymax - map.ymin) / 50000.) + 1
ugrid, lons1 = addcyclic(ugrid, lons1d)
ugrid, lons2 = shiftgrid(180., ugrid, lons1, start=False)
vgrid, lons1 = addcyclic(vgrid, lons1d)
vgrid, lons2 = shiftgrid(180., vgrid, lons1, start=False)
ugrid, vgrid, xx, yy = map.transform_vector(ugrid,
vgrid,
lons2,
lats1d,
nx,
ny,
returnxy=True)
# convert mps to knots.
ugrid = 1.943844 * ugrid
vgrid = 1.943844 * vgrid
spd = np.sqrt(ugrid**2 + vgrid**2)
x, y = map(lons, lats)
# mslp plot
fig = plt.figure(figsize=(10, 8))
map.drawcoastlines()
map.fillcontinents()
map.drawmeridians(np.arange(0, 360, 15),
labels=[0, 0, 0, 1],
delon = 45.
meridians = np.arange(-180,180,delon)
m.drawmeridians(meridians,labels=[1,1,1,1])
plt.title('Surface Winds Winds and Pressure (lat-lon grid)',y=1.075)
# plot vectors in map projection coordinates.
# north polar projection.
m = Basemap(lon_0=-135,boundinglat=25,round=True,
resolution='c',area_thresh=10000.,projection='npstere')
# transform from spherical to map projection coordinates (rotation
# and interpolation).
nxv = 41; nyv = 41
nxp = 101; nyp = 101
spd = np.sqrt(u**2+v**2)
udat, vdat, xv, yv = m.transform_vector(u,v,lons1,lats1,nxv,nyv,returnxy=True)
pdat, xp, yp = m.transform_scalar(p,lons1,lats1,nxp,nyp,returnxy=True)
# create a figure, add an axes.
fig=plt.figure(figsize=(8,8))
ax = fig.add_axes([0.1,0.1,0.7,0.7])
# plot image over map
im = m.imshow(pdat,plt.cm.jet)
# plot wind vectors over map.
Q = m.quiver(xv,yv,udat,vdat) #or specify, e.g., width=0.003, scale=400)
qk = plt.quiverkey(Q, 0.95, 1.05, 25, '25 m/s', labelpos='W')
m.colorbar(pad='12%') # draw colorbar
m.drawcoastlines()
m.drawcountries()
# draw parallels
delat = 20.
circles = np.arange(0.,90.+delat,delat).tolist()+\
plt.clf()
m=Basemap(projection='merc',llcrnrlat=lat[0,0],urcrnrlat=27.5,\
llcrnrlon=-89,urcrnrlon=lon[481,376],lat_ts=20,resolution='f')
# Draw a think border around the whole map
m.drawmapboundary(linewidth=3)
# Plot Data
xi, yi = m(lon2,lat2)
cs = m.pcolormesh(xi,yi,umag2,cmap=cm.gist_ncar_r,vmin=0.005, vmax = 0.5)
xi, yi = m(lon,lat)
cM = m.contour( xi,yi,scope2,[1,1],colors='k',linewidth=2.0)
# transform vectors to projection grid.
uproj,vproj,xx,yy = m.transform_vector(u2[::3,::3]*12,v2[::3,::3]*12,\
lonu[0,::3].squeeze(),latu[::3,0].squeeze(),\
60,60,returnxy=True,masked=True)
# now plot.
Q = m.quiver(xx,yy,uproj,vproj)#,scale=20)
# Add Grid Lines
m.drawparallels(np.arange(0.,90.,10.), labels=[1,0,0,0],\
fontsize=10, linewidth=0.75, color='.5')
m.drawmeridians(np.arange(-105.,-35.,10.), labels=[0,0,0,1],\
fontsize=10, linewidth=0.75, color='.5')
# Add Coastlines, States, and Country Boundaries
m.drawcoastlines()
m.drawstates()
m.drawcountries()
m.fillcontinents(color='grey')
animated=True)
# plot wind vectors on lat/lon grid.
# rotate wind vectors to map projection coordinates.
#urot,vrot = m.rotate_vector(u[nt,:,:],v[nt,:,:],lons,lats)
# plot wind vectors over map.
#Q = m.quiver(x,y,urot,vrot,scale=500)
# plot wind vectors on projection grid (looks better).
# first, shift grid so it goes from -180 to 180 (instead of 0 to 360
# in longitude). Otherwise, interpolation is messed up.
ugrid, newlons = shiftgrid(180., u[nt, :, :], longitudes, start=False)
vgrid, newlons = shiftgrid(180., v[nt, :, :], longitudes, start=False)
# transform vectors to projection grid.
urot, vrot, xx, yy = m.transform_vector(ugrid,
vgrid,
newlons,
latitudes,
51,
51,
returnxy=True,
masked=True)
# plot wind vectors over map.
Q = m.quiver(xx, yy, urot, vrot, scale=500)
# make quiver key.
qk = plt.quiverkey(Q, 0.1, 0.1, 20, '20 m/s', labelpos='W')
# draw coastlines, parallels, meridians, title.
m.drawcoastlines(linewidth=1.5)
m.drawparallels(parallels)
m.drawmeridians(meridians)
plt.title('SLP and Wind Vectors ' + str(date))
if nt == 0: # plot colorbar on a separate axes (only for first frame)
cax = plt.axes([l + w - 0.05, b, 0.03, h]) # setup colorbar axes
fig.colorbar(CS, drawedges=True, cax=cax) # draw colorbar
m.drawlsmask(land_color='0.7', ocean_color='white', lakes=True)
# draw lat/lon grid lines every 30 degrees.
m.drawmeridians(np.arange(0, 360, 30))
m.drawparallels(np.arange(-90, 90, 30))
x, y = m(X, Y)
# Set up to plot wind vectors on projection grid.
ugrid, newlons = shiftgrid(180., u_plot, lons, start=False)
vgrid, newlons = shiftgrid(180., v_plot, lons, start=False)
# Rotate and interpolate wind from lat/lon grid to map projection grid.
uproj, vproj, xx, yy = m.transform_vector(ugrid,
vgrid,
newlons,
lats,
41,
41,
returnxy=True)
if (plot_contours == 'true'):
CS = m.contour(x, y, plotvar, cflevs, colors='k', linewidths=1.5)
plt.clabel(CS, inline=1, fontsize=10, fmt='%i')
if plot_barbs == "true":
barbs = m.barbs(xx,
yy,
uproj,
vproj,
length=5,
barbcolor='k',
# compute native x,y coordinates of grid.
x, y = m(lons, lats)
# define parallels and meridians to draw.
parallels = np.arange(-80., 90, 20.)
meridians = np.arange(0., 360., 20.)
# plot SLP contours.
CS1 = m.contour(x, y, slp, clevs, linewidths=0.5, colors='k', animated=True)
CS2 = m.contourf(x, y, slp, clevs, cmap=plt.cm.RdBu_r, animated=True)
# plot wind vectors on projection grid.
# first, shift grid so it goes from -180 to 180 (instead of 0 to 360
# in longitude). Otherwise, interpolation is messed up.
ugrid, newlons = shiftgrid(180., u, longitudes, start=False)
vgrid, newlons = shiftgrid(180., v, longitudes, start=False)
# transform vectors to projection grid.
uproj,vproj,xx,yy = \
m.transform_vector(ugrid,vgrid,newlons,latitudes,31,31,returnxy=True,masked=True)
# now plot.
Q = m.quiver(xx, yy, uproj, vproj, scale=700)
# make quiver key.
qk = plt.quiverkey(Q, 0.1, 0.1, 20, '20 m/s', labelpos='W')
# draw coastlines, parallels, meridians.
m.drawcoastlines(linewidth=1.5)
m.drawparallels(parallels)
m.drawmeridians(meridians)
# add colorbar
cb = m.colorbar(CS2, "bottom", size="5%", pad="2%")
cb.set_label('hPa')
# set plot title
ax.set_title('SLP and Wind Vectors ' + str(date))
plt.show()
def plot_seasonal_winds(samples_folder,
seasons=commons.default_seasons,
level_hpa=850):
long_name = "Wind at {}hPa".format(level_hpa)
file_prefix = "dp"
plot_units = "m/s"
mult_coeff = 0.5144444444
add_offset = 0
out_dx = 0.5
lons2d, lats2d, u_season_to_mean, v_season_to_mean = calculate_seasonal_mean_winds(
seasons=seasons,
level_hpa=level_hpa,
samples_folder=samples_folder,
file_prefix=file_prefix)
# Plotting ++++++++++++++++++
plot_utils.apply_plot_params(width_cm=25, height_cm=15, font_size=18)
fig = plt.figure()
ncols = 2
gs = GridSpec(len(u_season_to_mean) // ncols +
int(not (len(u_season_to_mean) % ncols == 0)),
ncols,
wspace=0,
hspace=0)
xx, yy = None, None
bmp = Basemap(projection="robin", lon_0=0)
cmap = cm_basemap.GMT_no_green
clevs = None
for i, (sname, u_field) in enumerate(u_season_to_mean.items()):
row = i // ncols
col = i % ncols
ax = fig.add_subplot(gs[row, col])
lons, lats, u = commons.interpolate_to_uniform_global_grid(
u_field, lons_in=lons2d, lats_in=lats2d, out_dx=out_dx)
_, _, v = commons.interpolate_to_uniform_global_grid(
v_season_to_mean[sname],
lons_in=lons2d,
lats_in=lats2d,
out_dx=out_dx)
if xx is None:
xx, yy = bmp(lons, lats)
cs = bmp.contourf(xx,
yy, (u**2 + v**2)**0.5 * mult_coeff,
20 if clevs is None else clevs,
cmap=cmap,
extend="max")
uproj, vproj, xx_uv, yy_uv = bmp.transform_vector(u.transpose(),
v.transpose(),
lons[:, 0],
lats[0, :],
lons.shape[0],
lats.shape[1],
returnxy=True)
step = 15
qkey = bmp.quiver(xx_uv[::step, ::step],
yy_uv[::step, ::step],
uproj[::step, ::step],
vproj[::step, ::step],
scale=700)
# save color levels for next subplots
clevs = cs.levels
ax.set_title(sname)
cb = plt.colorbar(cs, ax=ax)
if not (row == 0 and col == ncols - 1):
# cb.ax.set_title(plot_units)
cb.ax.set_visible(False)
bmp.drawcoastlines(ax=ax, linewidth=LINEWIDTH)
fig.suptitle("{}, {}".format(long_name, plot_units))
img_folder = samples_folder.joinpath("images/seasonal")
if not img_folder.is_dir():
img_folder.mkdir(parents=True)
img_file = img_folder.joinpath("wind_vectors_{}hPa.eps".format(level_hpa))
with img_file.open("wb") as f:
fig.savefig(f, format="eps", bbox_inches="tight")
plt.close(fig)
m.drawcountries(linewidth=1, color='#444444', zorder=5)
m.drawstates(linewidth=0.66, color='#444444', zorder=4)
m.drawmapboundary
# draw lat/lon grid lines every 30 degrees.
m.drawmeridians(np.arange(0, 360, 30))
m.drawparallels(np.arange(-90, 90, 30))
x, y = m(X, Y)
CS = m.contourf(x,y,zeta_a1,cmap=plt.cm.hot_r,levels=cflevs, extend='both',zorder=1)
cbar = plt.colorbar(CS, shrink=0.95, orientation='horizontal',extend='both')
CS2 = m.contour(x, y, zeta_a1, cflevs, colors='k', linewidths=0.5)
if plot_barbs == "true":
# Rotate and interpolate wind from lat/lon grid to map projection grid.
uproj1,vproj1, xx1, yy1 = m.transform_vector(ugrid1,vgrid1,newlons,lats,41,41,returnxy=True)
barbs = m.barbs(xx1,yy1,uproj1,vproj1,length=5,barbcolor='k',flagcolor='r',linewidth=1.0)
cbar.set_ticks(cflevs_ticks)
clabs = ['%i K' % f for f in cflevs_ticks]
cbar.ax.set_yticklabels(clabs, size=10)
ax1.set_title(titletext1)
save_name = figname + "_01.png"
plt.savefig(save_name, bbox_inches='tight')
# Figure 2
fig = plt.figure(figsize=(8., 16./golden), dpi=128) # New figure
ax1 = fig.add_axes([0.1, 0.1, 0.8, 0.8])
def plot_gridded_ensemble(gfsx, contour_units=None, max_level=None,
barb_units='knot', cols=2, save_path=None, save_fmt='svg'):
"""
Plots the average windspeed deviation of ensemble forecast members over
the published GSF forecast for each grid point and forecast time.
The result is (for each forecast time) a color filled contour plot
indicating the ensemble deviation superimposed over the usual wind barbs
with the published GFS forecast vectors.
Parameters:
-----------
fcst_gfsx: xray.Dataset
Dataset with the GFS forecast for windspeed (uwnd and vwnd) and
ensemble forecast deviation (other forecast variables will be ignored
if present).
contour_units: str
The units in which to plot the ensemble spread indicator (heatmap). If
specified, the data sets current unit must be convertible into the
desired unit by slocum.lib.units. If not specified the exsiting units in
the data set will be used.
max_level: float
Heatmap/contour plot maximum level. Minimum level is assumed to be 0.
Values greater tha max_level will be mapped onto the max_level color.
If not specified, the maximum value found in the data set will be used
as the upper end of the color bar.
barb_units: str
Units in which to plot the GFS wind speed/direction forecast data (wind
bars). If specified, the data sets current unit must be convertible
into the desired unit by slocum.lib.units.
cols: int
Number of columns for subplot layout.
save_path: str
If specified the plot will be saved into this directory with file
name ``ens_<bounding box>_<t0>.svg`` where *bounding box* is
specified as *ll_lat, ll_lon - ur_lat, ur_lon*. If not specified or
``None`` the plot will be displayed interactively.
save_fmt: str
Format under which to save the image (only relevant if *save_path* is
specified). Can be any image file extension that plt.savefig() will
recognize as a valid format.
"""
# adjust units as requested:
for v in (conv.UWND, conv.VWND):
units.convert_units(gfsx[v], barb_units)
if contour_units:
units.convert_units(gfsx[conv.ENS_SPREAD_WS], contour_units)
if not max_level:
max_level = gfsx[conv.ENS_SPREAD_WS].max()
if isinstance(gfsx, np.datetime64): # True is gfsx has not been packed
f_times = gfsx[conv.TIME].values
else: # time variable has int offsets
f_times = xray.conventions.decode_cf_datetime(
gfsx['time'], gfsx['time'].attrs['units'])
lats = gfsx[conv.LAT].values
lons = gfsx[conv.LON].values
# Basemap.transform_vector requires lats and lons each to be in ascending
# order:
lat_inds = range(len(lats))
lon_inds = range(len(lons))
if NautAngle(lats[0]).is_north_of(NautAngle(lats[-1])):
lat_inds.reverse()
lats = lats[lat_inds]
if NautAngle(lons[0]).is_east_of(NautAngle(lons[-1])):
lon_inds.reverse()
lons = lons[lon_inds]
# determine layout:
fig_width_inches = 10
plot_aspect_ratio = (abs(lons[-1] - lons[0]) /
float(abs(lats[-1] - lats[0])))
rows = int(np.ceil(gfsx.dimensions[conv.TIME] / float(cols)))
fig_height_inches = (fig_width_inches / (float(cols) * plot_aspect_ratio)
* rows + 2)
fig = plt.figure(figsize=(fig_width_inches, fig_height_inches))
fig.suptitle("GFS wind forecast in %s and "
"ensemble wind speed deviation" % barb_units,
fontsize=12)
grid = AxesGrid(fig, [0.01, 0.01, 0.95, 0.93],
nrows_ncols=(rows, cols),
axes_pad=0.8,
cbar_mode='single',
cbar_pad=0.0,
cbar_size=0.2,
cbar_location='bottom',
share_all=True,)
# size for lat/lon labels, timestamp:
label_fontsize = 'medium' if cols <= 2 else 'small'
# format string for colorbar labels:
decimals = max(0, int(2 - np.floor(np.log10(max_level))))
cb_label_fmt = '%.' + '%d' % decimals + 'f'
# heatmap color scaling and levels
spread_levels = np.linspace(0., max_level, 50)
m = Basemap(projection='merc', llcrnrlon=lons[0], llcrnrlat=lats[0],
urcrnrlon=lons[-1], urcrnrlat=lats[-1], resolution='l')
for t_step, t in enumerate(f_times):
ax = grid[t_step]
m.drawcoastlines(ax=ax)
m.drawparallels(lats,labels=[1,0,0,0], ax=ax,
fontsize=label_fontsize)
m.drawmeridians(lons,labels=[0,0,0,1], ax=ax,
fontsize=label_fontsize, rotation='vertical')
# ensemble spread heatmap:
x, y = m(*np.meshgrid(lons, lats))
data = gfsx[conv.ENS_SPREAD_WS]
data = data.indexed(**{conv.TIME: t_step})
data = data.indexed(**{conv.LAT: lat_inds})
data = data.indexed(**{conv.LON: lon_inds}).values
cs = m.contourf(x, y, data, spread_levels, ax=ax, extend='max',
cmap=cm.jet)
# wind barbs:
u = gfsx[conv.UWND].indexed(**{conv.TIME: t_step})
u = u.indexed(**{conv.LAT: lat_inds})
u = u.indexed(**{conv.LON: lon_inds}).values
v = gfsx[conv.VWND].indexed(**{conv.TIME: t_step})
v = v.indexed(**{conv.LAT: lat_inds})
v = v.indexed(**{conv.LON: lon_inds}).values
# transform from spherical to map projection coordinates (rotation
# and interpolation).
nxv = len(lons)
nyv = len(lats)
barb_length = 8 - cols
barb_width = 1.2 - (cols / 10.)
udat, vdat, xv, yv = m.transform_vector(
u, v, lons, lats, nxv, nyv, returnxy=True)
# plot barbs.
m.barbs(xv, yv, udat, vdat, ax=ax, length=barb_length, barbcolor='w',
flagcolor='r', linewidth=barb_width)
ax.set_title(t.astype('M8[h]').item().strftime('%Y-%m-%dT%H:%MZ'),
fontsize=label_fontsize)
cbar = fig.colorbar(cs, cax=grid.cbar_axes[0], orientation='horizontal',
format=cb_label_fmt)
attr = gfsx[conv.ENS_SPREAD_WS].attrs
cb_label = attr.get('long_name',
'Average (normalized) wind speed delta (ens - gfs)')
s = ["%s = %s" % (k, attr[k]) for k in attr if k != 'long_name']
if s:
cb_label = "%s (%s)" % (cb_label, ', '.join(s))
cbar.set_label(cb_label)
if save_path:
t0_str = f_times[0].astype('M8[h]').item().strftime('%Y%m%dT%H%MZ')
file_name = "ens_%s%s-%s%s_%s.%s" % (
NautAngle(lats[0]).named_str(conv.LAT),
NautAngle(lons[0]).named_str(conv.LON),
NautAngle(lats[-1]).named_str(conv.LAT),
NautAngle(lons[-1]).named_str(conv.LON),
t0_str, save_fmt)
plt.savefig(os.path.join(save_path, file_name), bbox_inches='tight')
else:
plt.show()
plt.close()
x, y = m(lons, lats)
for ii in range(ntimes):
cs = m.contour(x, y, hgt[ii, 0, :, :], colors='b', linewidths=1.5)
cs1 = m.contour(x,
y,
t[ii, 0, :, :],
colors='r',
linestyle='dash',
linewidths=1.5)
clevs = [-70, -30, -20, -10, 0, 10, 20, 30, 70]
cs2 = m.contourf(x, y, T_adv[ii, :, :], clevs,
cmap=plt.cm.RdBu_r) #plt.cm.OrRd)
cb = m.colorbar(cs2, "right", size="5%", pad='2%')
cb.set_label('Thermal advection: $10^{-5}$')
plt.clabel(cs, fontsize=10, fmt='%1d')
plt.clabel(cs1, fontsize=10, fmt='%1d')
ugrid, newlons = shiftgrid(180., u, longitude, start=False)
vgrid, newlons = shiftgrid(180., v, longitude, start=False)
uproj,vproj,xx,yy = \
m.transform_vector(ugrid[ii,0,::-1,:],vgrid[ii,0,::-1,:],newlons,latitude[::-1],31,31,returnxy=True,masked=True)
Q = m.quiver(xx, yy, uproj, vproj, units='inches')
qk = plt.quiverkey(Q, 0, -0.1, 5, '5 m/s', labelpos='S')
m.drawcoastlines(linewidth=0.5)
m.drawparallels(np.arange(-90, 90, 5), labels=[1, 0, 0, 0])
m.drawmeridians(np.arange(0, 360, 5), labels=[0, 0, 0, 1])
dend = dstart + datetime.timedelta(hours=float(del_t[ii]))
plt.title(np.str(dend))
plt.savefig("/Users/QQF/Downloads/" + np.str(dend) + ".png", dpi=600)
plt.close('all')
#clabs = ['%i' % f for f in cflevs_trth]
labels = [item.get_text() for item in cbar.ax.get_xticklabels()]
cbar.ax.set_xticklabels(labels, size=20)
cbar.set_label(cbarlabel, size=20)
if plot_field == 'quivwind':
ugrid, newlons = shiftgrid(180., uwind, lons, start=False)
vgrid, newlons = shiftgrid(180., vwind, lons, start=False)
# transform vectors to projection grid.
uproj, vproj, xx, yy = m.transform_vector(ugrid[::-1, :],
vgrid[::-1, :],
newlons,
lats[::-1],
61,
61,
returnxy=True,
masked=True)
# now plot.
Q = m.quiver(xx,
yy,
uproj,
vproj,
scale=700,
color='g',
linewidths=(1, ),
edgecolors=('g'),
headaxislength=2)
if plot_trth_contours == 'True':
