def polar_stere(lon_w, lon_e, lat_s, lat_n, **kwargs):
'''Returns a Basemap object (NPS/SPS) focused in a region.
lon_w, lon_e, lat_s, lat_n -- Graphic limits in geographical coordinates.
W and S directions are negative.
**kwargs -- Aditional arguments for Basemap object.
'''
lon_0 = lon_w + (lon_e - lon_w) / 2.
ref = lat_s if abs(lat_s) > abs(lat_n) else lat_n
lat_0 = math.copysign(90., ref)
proj = 'npstere' if lat_0 > 0 else 'spstere'
prj = basemap.Basemap(projection=proj,
lon_0=lon_0,
lat_0=lat_0,
boundinglat=0,
resolution='c')
#prj = pyproj.Proj(proj='stere', lon_0=lon_0, lat_0=lat_0)
lons = [lon_w, lon_e, lon_w, lon_e, lon_0, lon_0]
lats = [lat_s, lat_s, lat_n, lat_n, lat_s, lat_n]
x, y = prj(lons, lats)
ll_lon, ll_lat = prj(min(x), min(y), inverse=True)
ur_lon, ur_lat = prj(max(x), max(y), inverse=True)
return basemap.Basemap(projection='stere',
lat_0=lat_0,
lon_0=lon_0,
llcrnrlon=ll_lon,
llcrnrlat=ll_lat,
urcrnrlon=ur_lon,
urcrnrlat=ur_lat,
**kwargs)
def drawmaps(ax,
lat_mn,
lon_mn,
lat_mx,
lon_mx,
swath_lon,
swath_lat,
proj=None,
gvmap=False):
#lat_mn, lat_mx : integers
#proj : "cyl" and "ortho"
if proj == None:
proj = 'ortho'
if proj == 'cyl':
mapproj = bm.Basemap(ax=ax,projection='cyl',llcrnrlat= lat_mn, \
llcrnrlon= lon_mn,urcrnrlat= lat_mx, urcrnrlon= lon_mx)
elif proj == 'ortho':
lon_0 = lon_mn + (lon_mx - lon_mn) / 2
lat_0 = lat_mn + (lat_mx - lat_mn) / 2
#lower right and upper right
m1 = bm.Basemap(projection='ortho',
lon_0=lon_0,
lat_0=lat_0,
resolution=None)
#
xp0, yp0 = m1(lon_0, lat_0)
#
xp1, yp1 = m1(swath_lon[0, 0], swath_lat[0, 0])
xp2, yp2 = m1(swath_lon[0, -1], swath_lat[0, -1])
xp3, yp3 = m1(swath_lon[-1, -1], swath_lat[-1, -1])
xp4, yp4 = m1(swath_lon[-1, 0], swath_lat[-1, 0])
llx = min(xp1, xp2, xp3, xp4) - xp0 # lower left
lly = min(yp1, yp2, yp3, yp4) - yp0
urx = max(xp1, xp2, xp3, xp4) - xp0 # upper right
ury = max(yp1, yp2, yp3, yp4) - yp0
mapproj = bm.Basemap(ax=ax,projection='ortho',lon_0=lon_0,\
lat_0=lat_0,resolution='l',llcrnrx=llx,llcrnry=lly,\
urcrnrx=urx,urcrnry=ury)
else:
print('Only ortho or cyl projections!!')
lonproj, latproj = mapproj(swath_lon, swath_lat)
latlines = np.arange(lat_mn, lat_mx, 5.0)
lonlines = np.arange(lon_mn, lon_mx, 10.0)
mapproj.drawcoastlines()
mapproj.drawparallels(latlines, labels=[1, 0, 0, 0])
mapproj.drawmeridians(lonlines, labels=[0, 0, 0, 1])
ax.patch.set_color('gray')
if gvmap:
return lonproj, latproj, mapproj
else:
return lonproj, latproj
def rgbproj(lon_mn, lon_mx, lat_mn, lat_mx, swath_lat, swath_lon, red, green,
blue, ax):
lon_0 = lon_mn + (lon_mx - lon_mn) / 2
lat_0 = lat_mn + (lat_mx - lat_mn) / 2
#lower right and upper right
m1 = bm.Basemap(projection='ortho',
lon_0=lon_0,
lat_0=lat_0,
resolution=None)
xp0, yp0 = m1(lon_0, lat_0)
xp1, yp1 = m1(swath_lon[0, 0], swath_lat[0, 0])
xp2, yp2 = m1(swath_lon[0, -1], swath_lat[0, -1])
xp3, yp3 = m1(swath_lon[-1, -1], swath_lat[-1, -1])
xp4, yp4 = m1(swath_lon[-1, 0], swath_lat[-1, 0])
llx = min(xp1, xp2, xp3, xp4) - xp0 # lower left
lly = min(yp1, yp2, yp3, yp4) - yp0
urx = max(xp1, xp2, xp3, xp4) - xp0 # upper right
ury = max(yp1, yp2, yp3, yp4) - yp0
# m = bm.Basemap(projection='cyl',lon_0=lon_0,lat_0=lat_0,resolution='l',\
# llcrnrlon=lon_mn,llcrnrlat=lat_mn,urcrnrlon=lon_mx,urcrnrlat=lat_mx,\
# llcrnrx=llx,llcrnry=lly,urcrnrx=urx,urcrnry=ury)
m = bm.Basemap(ax=ax,projection='ortho',lon_0=lon_0,lat_0=lat_0,resolution='l',\
llcrnrx=llx,llcrnry=lly,urcrnrx=urx,urcrnry=ury)
x_igrid, y_igrid = m(swath_lon, swath_lat)
x_igrid = x_igrid - xp0
y_igrid = y_igrid - yp0
x1_igrid = x_igrid.ravel()
y1_igrid = y_igrid.ravel()
z_igrid_01 = red.ravel()
z_igrid_02 = green.ravel()
z_igrid_03 = blue.ravel()
xy1_igrid = np.vstack((x1_igrid, y1_igrid)).T
xi, yi = np.mgrid[llx:urx:1000j, lly:ury:1000j]
z_01 = griddata(xy1_igrid, z_igrid_01, (xi, yi), method='linear')
z_02 = griddata(xy1_igrid, z_igrid_02, (xi, yi), method='linear')
z_03 = griddata(xy1_igrid, z_igrid_03, (xi, yi), method='linear')
rgb_projected = np.zeros((1000, 1000, 3))
rgb_projected[:, :, 0] = z_01[:, :]
rgb_projected[:, :, 1] = z_02[:, :]
rgb_projected[:, :, 2] = z_03[:, :]
rgb_projected = np.rot90(np.flipud(rgb_projected), k=3)
return m, rgb_projected
def AfrBasemap2(lat,lon,latsp,lonsp,drawstuff=False,prj='cyl', rsltn='c',\
fontdict=False,onlyedge=False):
'''m = SAfrBasemap(lat,lon,drawstuff=False,prj='cyl',fno=1)
Adapted from N Hart MetBlobs SAfBasemap
this one does not create figure "f"
This creates a basemap instance from lat's and lon's provided.
Specific for this application of metblobs, so currently using proj='cyl',
however Albers equal area is here uncommented.
USAGE: lat, lon
RETURNS: m, basemap object pointer (handle in matlab language)'''
xy = (lat.min(), lat.max(), lon.min(), lon.max())
nx = len(lon)
ny = len(lat)
if not fontdict: fontdict = {'fontsize': 10, 'fontweight': 'normal'}
if prj == 'cyl':
m = bm.Basemap(llcrnrlon=xy[2],llcrnrlat=xy[0],urcrnrlon=xy[3],\
urcrnrlat=xy[1],resolution=rsltn,area_thresh=10000.,\
projection='cyl')
if prj == 'aea':
m = bm.Basemap(llcrnrlon=xy[2]-5.,llcrnrlat=xy[0],urcrnrlon=xy[3],\
urcrnrlat=xy[1]+5,resolution=rsltn,projection='aea',\
lat_1=-45.,lat_2=0.,lon_0=40.)
### SET UP FIGURE AND MERIDIANS
delon = lonsp
meridians = np.arange(0., 360., delon)
delat = latsp
circles = np.arange(0.,90.+delat,delat).tolist()+\
np.arange(-delat,-90.-delat,-delat).tolist()
if drawstuff:
m.drawcoastlines()
m.drawcountries()
if not onlyedge:
m.drawparallels(circles,linewidth='0.1',labels=[1,0,0,0],\
fontdict=fontdict)
m.drawmeridians(meridians,linewidth='0.1',labels=[0,0,0,1],\
fontdict=fontdict)
elif onlyedge == 'lat':
m.drawparallels(circles,linewidth='0.1',labels=[1,0,0,0],\
fontdict=fontdict)
elif onlyedge == 'lon':
m.drawmeridians(meridians,linewidth='0.1',labels=[0,0,0,1],\
fontdict=fontdict)
return m
def mapProject(ax,
lat={
'mn': -90,
'mx': 90
},
lon={
'mn': -180,
'mx': 180
},
line_step={
'lon': 45.0,
'lat': 30.0
}):
lat_int = line_step['lat']
lon_int = line_step['lon']
mapproj = bm.Basemap(ax=ax,
projection='cyl',
llcrnrlat=lat['mn'],
llcrnrlon=lon['mn'],
urcrnrlat=lat['mx'],
urcrnrlon=lon['mx'])
latlines = np.arange(lat['mn'], lat['mx'], lat_int)
lonlines = np.arange(lon['mn'], lon['mx'], lon_int)
mapproj.drawcoastlines()
mapproj.drawparallels(latlines, labels=[1, 0, 0, 0])
mapproj.drawmeridians(lonlines, labels=[0, 0, 0, 1])
return mapproj
def map_peninsula (lon, lat, xvar, centerlon=-60, w=2000,h=2000, cb=False, cl=None, cbtitle=None, ec='None', ax=None, fp=None):
from mpl_toolkits import basemap
from matplotlib.pyplot import colorbar
import niceplots
m = basemap.Basemap(projection='lcc',lat_0=-70,lon_0=centerlon,width=w*1000,height=h*1000, resolution='i', ax=ax)
x, y = m(lon, lat)
if cl is None:
pc = m.pcolormesh(x, y, xvar, edgecolors=ec)
else:
pc = m.pcolormesh(x, y, xvar, vmin=cl[0], vmax=cl[1], edgecolors=ec)
m.drawmapboundary(color='grey')
if fp:
m.drawmeridians(np.arange(-105,-15,15), labels=[0,0,0,1], fontproperties=fp) # left, right, top, bottom
m.drawparallels(np.arange(-90,90,10), labels=[1,0,0,0], fontproperties=fp) # left, right, top, bottom
else:
m.drawmeridians(np.arange(-105,-15,15), labels=[0,0,0,1]) # left, right, top, bottom
m.drawparallels(np.arange(-90,90,10), labels=[1,0,0,0]) # left, right, top, bottom
m.drawcoastlines(color='grey')
if cb:
cbar=colorbar(pc)
if fp:
niceplots.beautify_colorbar(cbar, title=cbtitle)
else:
if cbtitle is not None:
cbar.set_label(cbtitle)
return m, pc
def test_scalar_grid(min_lon=0.0, max_lon=np.pi, min_lat=-np.pi/2.0, max_lat=np.pi/2.0,\
nlats=181, nlons=181, field='tens', cmap=plt.cm.gray_r): #{{{
satfile = "input/ConvectingEuropa_GlobalDiurnalNSR.ssrun"
europa = ss.Satellite(open(satfile, 'r'))
NSR = ss.StressCalc([
ss.NSR(europa),
])
the_fig = plt.figure(figsize=(10, 10))
map_ax = the_fig.add_subplot(1, 1, 1)
map_ax.set_title("Rasterized scalar stress field (%s)" % (field, ))
scalar_basemap = basemap.Basemap(llcrnrlon = np.degrees(min_lon),\
llcrnrlat = np.degrees(min_lat),\
urcrnrlon = np.degrees(max_lon),\
urcrnrlat = np.degrees(max_lat),\
ax = map_ax)
scalar_grid(stresscalc=NSR, nlons=nlons, nlats=nlats, min_lon=min_lon, max_lon=max_lon, min_lat=min_lat, max_lat=max_lat,\
field=field, cmap=cmap, basemap_ax=scalar_basemap)
scalar_basemap.drawmeridians(np.degrees(np.linspace(min_lon, max_lon, 7)),
labels=[1, 0, 0, 1],
linewidth=0.5,
color='gray')
scalar_basemap.drawparallels(np.degrees(np.linspace(min_lat, max_lat, 7)),
labels=[1, 0, 0, 1],
linewidth=0.5,
color='gray')
scalar_basemap.drawmapboundary()
def drawMap(ax):
"""Creates basemap with standard properties.
Args:
ax (matplotlib.axes): Axes to display plots in.
Returns:
matplotlib.basemap.basemap: Basemap.
"""
# Create basemap
m = bm.Basemap( #llcrnrlon=-lonMin,llcrnrlat=latMin,urcrnrlon=lonMax,urcrnrlat=latMax,
projection='lcc',
lat_0=45.,
lon_0=-63.,
resolution='l',
area_thresh=10000.,
ax=ax,
suppress_ticks=True,
width=1000 * 1E3,
height=700 * 1E3)
# Some settings
m.drawcoastlines()
m.fillcontinents(color='coral', lake_color='aqua')
m.drawmapboundary(fill_color='aqua')
m.drawparallels(np.arange(-80, 80, 10.))
m.drawmeridians(np.arange(-180, 180., 10))
return m
def plotCode(timeseries, climatology, modelID):
years = timeseries.coord('year').points
f = plt.figure(figsize=(15, 5))
plt.subplot(1, 2, 1)
plt.bar(years, timeseries.data)
plt.xlabel('years')
plt.ylabel('precip kg m-2 day-1')
#plt.xlim(0, len(timeseries.data))
plt.title('JJAS pr 5S-20N ; 18W-15E: ' + modelID)
plt.subplot(1, 2, 2)
levs = np.linspace(1, 20, 20)
iplt.contourf(climatology, levs, cmap='jet_r')
m = bm.Basemap(projection='cyl',
llcrnrlat=np.min(climatology.coord('latitude').points),
urcrnrlat=np.max(climatology.coord('latitude').points),
llcrnrlon=np.min(climatology.coord('longitude').points),
urcrnrlon=np.max(climatology.coord('longitude').points),
resolution='c') # medium resolution for grid
m.drawcoastlines(linewidth=2)
m.drawcountries(linewidth=1)
plt.title('JJAS mean pr (1950-2005) 5S-20N ; 18W-15E:' + modelID)
cbar = plt.colorbar(orientation="vertical")
cbar.set_label('precip kg m-2 day-1')
#qplt.pcolor(climatology)
#plt.tight_layout()
plt.savefig(
'/nfs/see-fs-01_teaching/earv057/metrics_workshop/Ev_To/Figures_png/' +
modelID + 'jjas.png')
def test_scalar_lin(lin, field='tens', cmap=plt.cm.jet): #{{{
import lineament
satfile="input/ConvectingEuropa_GlobalDiurnalNSR.ssrun"
europa = ss.Satellite(open(satfile,'r'))
NSR = ss.StressCalc([ss.NSR(europa),])
mp_lons, mp_lats = lin.seg_midpoints()
seg_lengths = lin.seg_lengths()
min_lat = 0
max_lat = np.pi/2.0
min_lon = 0.0
max_lon = np.pi
the_fig = plt.figure(figsize=(10,10))
map_ax = the_fig.add_subplot(1,1,1)
map_ax.set_title("Point by Point scalar stresses field (%s)" % (field,) )
scalar_basemap = basemap.Basemap(llcrnrlon = np.degrees(min_lon),\
llcrnrlat = np.degrees(min_lat),\
urcrnrlon = np.degrees(max_lon),\
urcrnrlat = np.degrees(max_lat),\
ax = map_ax)
scalar_points(stresscalc=NSR, lons=np.mod(mp_lons,np.pi), lats=np.mod(mp_lats,np.pi/2.0), symb_sizes=5000*seg_lengths, field=field, cmap=cmap, basemap_ax=scalar_basemap)
junk = lineament.plotlinmap([lin,], map=scalar_basemap, lat_mirror=True, lon_cyc=np.pi)
scalar_basemap.drawmeridians(np.degrees(np.linspace(min_lon, max_lon, 7)), labels=[1,0,0,1], linewidth=0.5, color='gray')
scalar_basemap.drawparallels(np.degrees(np.linspace(min_lat, max_lat, 7)), labels=[1,0,0,1], linewidth=0.5, color='gray')
scalar_basemap.drawmapboundary()
def stereographic(lat, lon, time):
plt.figure()
mapPlot = bm.Basemap(projection='npstere', boundinglat=10, lon_0=0, resolution='i')
mapPlot.drawcoastlines()
mapPlot.fillcontinents(color='coral', lake_color='aqua')
mapPlot.drawparallels(np.arange(-80., 81., 20.))
mapPlot.drawmeridians(np.arange(-180., 181., 20.))
mapPlot.drawmapboundary(fill_color='aqua')
mapPlot.plot(misc.bhv[0], misc.bhv[1], 'go', latlon=True)
mapPlot.plot(misc.tro[0], misc.tro[1], 'go', latlon=True)
mapPlot.plot(misc.lby[0], misc.lby[1], 'go', latlon=True)
for i in range(len(lon)):
if(time[i].month == 5):
colour = "bo"
mapPlot.plot(lon[i], lat[i], colour, latlon=True, mew=0.2, markersize=misc.ms)
elif(time[i].month == 6):
colour = "go"
mapPlot.plot(lon[i], lat[i], colour, latlon=True, mew=0.2, markersize=misc.ms)
elif(time[i].month == 7):
colour = "yo"
mapPlot.plot(lon[i], lat[i], colour, latlon=True, mew=0.2, markersize=misc.ms)
elif(time[i].month == 8):
colour = "co"
mapPlot.plot(lon[i], lat[i], colour, latlon=True, mew=0.2, markersize=misc.ms)
plt.show()
plt.close()
def doPlotRetLevChng(ax, rlChng, lon, lat, txt, mp):
if mp == None:
#llcrnrlon = -11.5
#llcrnrlat = 23
#urcrnrlon = 44
#urcrnrlat = 74
#llcrnrlon = -25
#llcrnrlat = 31
#urcrnrlon = 37
#urcrnrlat = 71.5
llcrnrlon = -25
llcrnrlat = 25
urcrnrlon = 44
urcrnrlat = 71.5
mp = bm.Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat, resolution='l', projection='lcc', lon_0=-15, lat_1=-15, lat_2=10)
plt.axes(ax)
mp.drawcoastlines(linewidth=.25)
pltvls = rlChng
x, y = mp(lon, lat)
sc = plt.scatter(x, y, s=1, c=pltvls, vmin=-40, vmax=40, linewidth=0, cmap='bwr_r')
txtpos = mp(-22, 68)
plt.annotate(txt, xy=txtpos, xycoords='data', xytext=txtpos, textcoords='data', fontsize=19)
return sc, mp
def workshop_metrics_mean_temperature(Temp1, figdir):
'''
Inputs
- incube : A 3D cube with time, lat and lon dimensions (iris cube)
- figdir : An output path to write the figure to (chr string)
Outputs
- a nice plot of the huvmoller
'''
#levels=np.linspace(282,302,10)
a = np.max(Temp1[:, :])
b = np.min(Temp1[:, :])
levels = np.linspace(np.amin(Temp1[:, :]), np.max(Temp1[:, :]), 13)
#print(levs)
print levels
qplt.contourf(Temp1, levels=levels, extend='max')
#fig1=qplt.contourf(Temp1, levels = levels, extend = 'max')
#plt.clabel(fig1, inline=1) #adds numbers to your contours
m = bm.Basemap(projection='cyl',
llcrnrlat=8.0,
urcrnrlat=16.0,
llcrnrlon=-20.0,
urcrnrlon=20.0,
resolution='c') # coarse resolution for grid
m.drawcoastlines(linewidth=2)
m.drawcountries(linewidth=1)
plt.savefig(figdir + 'Tmean.png')
plt.show()
def plot(self):
"""Plot ra and dec"""
m = basemap.Basemap(projection='moll', lon_0=270, resolution='c')
# draw parallels and meridians.
m.drawparallels(np.arange(-90., 120., 30.),
linewidth=0.5,
labels=[1, 0, 0, 0],
labelstyle='+/-')
m.drawmeridians(np.arange(0., 420., 60.), linewidth=0.5)
m.drawmapboundary()
boundary = 90.
ncirc = 60
theta = np.arange(ncirc) * np.pi * 2. / np.float32(ncirc - 1)
for (ra, dec) in zip(self.ra, self.dec):
cra = (ra +
self.radius / np.cos(dec * np.pi / 180.) * np.cos(theta))
cdec = dec + self.radius * np.sin(theta)
nbelow = np.count_nonzero(cra < boundary)
if (nbelow > 0):
ibelow = np.nonzero(cra < boundary)[0]
(xx, yy) = self._convert_radec(m, cra[ibelow], cdec[ibelow])
plt.plot(xx, yy, linewidth=0.25, color='blue')
nabove = np.count_nonzero(cra > boundary)
if (nabove > 0):
iabove = np.nonzero(cra > boundary)[0]
(xx, yy) = self._convert_radec(m, cra[iabove], cdec[iabove])
plt.plot(xx, yy, linewidth=0.25, color='blue')
def map(fname, source=csvfile, nlat=180, nlon=180, cmap='gist_ncar_r', cmin=0, cmax=7):
data = getdata.read(source)
Z, latedges, lonedges, binnumber = stats.binned_statistic_2d(data.Latitude, data.Longitude, data.LimitingMag, statistic=statistic, bins=(nlat, nlon))
fig, ax = plt.subplots(figsize=(20,15))
norm = colors.Normalize(vmin=cmin, vmax=cmax)
scalar_map = cm.ScalarMappable(norm=norm, cmap=cmap)
m = basemap.Basemap(projection='robin',lon_0=0,resolution='i', ax=ax)
m.drawcoastlines(linewidth=0.2)
m.fillcontinents(color = 'grey', lake_color = 'white')
X, Y = np.meshgrid(lonedges[:-1], latedges[:-1])
Xf = X.flatten()
Yf = Y.flatten()
Zf = Z.flatten()
Xf = Xf[Zf<=7]
Yf = Yf[Zf<=7]
Zf = Zf[Zf<=7]
color = scalar_map.to_rgba(Zf)
x, y = m(Xf, Yf)
for i in range(len(Zf)):
m.plot(x[i], y[i], marker='s', ls='', color=color[i], markersize=2)
scalar_map.set_array(Zf)
cbar = plt.colorbar(scalar_map)
cbar.ax.tick_params(labelsize=ticksize)
ax.set_title('Limiting Magnitude (%s x %s)' % (nlat, nlon), fontsize=titlefont)
fig.savefig(fname, dpi=300)
def plotMapAtTime(ncfilepath, timeIndex):
ds = netCDF4.Dataset(ncfilepath)
hs = ds.variables['hs'][timeIndex, :]
#hs = ds.variables['vwnd'][timeIndex, :]
xs = ds.variables['longitude'][:]
ys = ds.variables['latitude'][:]
hs[hs.mask] = 0
tm = ds.variables['time']
dtm = netCDF4.num2date(tm[timeIndex], tm.units, 'standard')
print('printing for date ' + str(dtm))
f = plt.figure(figsize=[12, 6])
bm = basemap.Basemap(llcrnrlon=min(xs), llcrnrlat=min(ys), urcrnrlon=max(xs), urcrnrlat=max(ys), resolution='i')
bm.drawcoastlines()
mx = np.percentile(hs.flatten(), 99.5) + .6
hs[hs > mx - .1] = mx - .1
levels = np.arange(0., mx, .02)
cmap = 'ocean_r'
cf = bm.contourf(xs, ys, hs, levels, tri=True, cmap=cmap)
cf.cmap.set_over([.5,0,0])
plt.triplot(xs, ys, linewidth=.1, color='k')
fc = bm.fillcontinents(color=[.8, .8, .8],lake_color=[.8, .8, .8])
[fci.set_zorder(20) for fci in fc]
#cf.set_clim(0, 1.6)
cb = bm.colorbar()
cb.ax.set_ylabel('Hs (m)', fontsize=15)
f.tight_layout()
plt.savefig('pltTriMed_t=' + str(timeIndex) + '.png', dpi=400)
plt.show()
def plot_array(array, lat, lon, lat_lims, lon_lims):
# Corners of subset map
lat1 = lat_lims[0]
lat2 = lat_lims[1]
lon1 = lon_lims[0]
lon2 = lon_lims[1]
cmap = copy.copy(plt.cm.RdBu_r)
fig = plt.figure(figsize=(10,5))
ax = fig.add_subplot(111)
m = basemap.Basemap(projection='mill',
llcrnrlat=lat1, urcrnrlat=lat2,
llcrnrlon=lon1, urcrnrlon=lon2,
lat_ts=20, resolution='c')
lons1, lats1 = np.meshgrid(lon, lat)
x, y = m(lons1, lats1)
m.drawcoastlines()
ds_new = maskoceans(lons1, lats1, array)
levels = np.linspace(-0.5, 0.5, 11)
cs = m.contourf(x, y, ds_new, levels=levels, cmap=cmap, extend='both')
plt.colorbar(cs, orientation='vertical', pad=0.05)
title = ("Zeng's gamma")
ax.set_title(title)
path = str(os.getcwd()) + '/'
print(path)
today = datetime.today()
date = today.strftime("_%d.%m.%Y")
fname = 'zengs_gamma' + date + '.png'
plt.savefig(path+fname, dpi=300, bbox_inches='tight')
def plotSigma(ax, sigma, mp, txt, txt2='', sigmamax=30):
if mp == None:
#llcrnrlon = -11.5
#llcrnrlat = 23
#urcrnrlon = 44
#urcrnrlat = 74
llcrnrlon = -25
llcrnrlat = 31
urcrnrlon = 37
urcrnrlat = 71.5
mp = bm.Basemap(llcrnrlon=llcrnrlon,
llcrnrlat=llcrnrlat,
urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat,
resolution='l',
projection='lcc',
lon_0=-15,
lat_1=-15,
lat_2=10)
lon, lat = estimateChngSignificanceAndRobustness.getLonLat()
#lon, lat = lon.transpose(), lat.transpose()
x, y = mp(lon, lat)
plt.axes(ax)
mp.drawcoastlines(linewidth=.25)
mp.fillcontinents(color=[.95, .95, .95],
lake_color=[.95, .95, .95],
zorder=0)
absSigma_ = np.abs(sigma)
absSigma = bm.maskoceans(lon, lat, absSigma_)
#pcl = mp.scatter(x.flatten(), y.flatten(), .07, c=absSigma.flatten(), cmap='Oranges', alpha=1, vmin=0, vmax=sigmamax)
pcl = mp.pcolor(x,
y,
absSigma,
cmap='Oranges',
alpha=1,
vmin=0,
vmax=sigmamax)
txtpos = mp(-21, 69.5)
plt.annotate(txt,
xy=txtpos,
xycoords='data',
xytext=txtpos,
textcoords='data',
fontsize=13)
if txt2 != '':
txtpos = mp(-17, 67.5)
plt.annotate(txt2,
xy=txtpos,
xycoords='data',
xytext=txtpos,
textcoords='data',
fontsize=14,
weight='bold')
return pcl, mp
def figmap2(lon, lat, lonmin, lonmax, latmin, latmax, res, fsize):
m = bm.Basemap(projection='merc',
llcrnrlat=latmin,
llcrnrlon=lonmin,
urcrnrlat=latmax,
urcrnrlon=lonmax,
resolution=res)
x, y = m(lon, lat)
m.drawparallels(np.arange(10 * np.floor(lat.min() / 10),
10 * np.ceil(lat.max() / 10), 10.),
labels=[True, False, False, False],
fontsize=fsize,
linewidth=0.15)
m.drawmeridians(np.arange(10 * np.floor(lon.min() / 10),
10 * np.ceil(lon.max() / 10), 10.),
labels=[False, False, False, True],
fontsize=fsize,
linewidth=0.15)
m.fillcontinents(color='grey')
#plt.xlabel('Longitude',labelpad=20)
#plt.ylabel('Latitude',labelpad=40)
return m, x, y
def plotRelChngDiff(ax, relChngDiff, mp, txt, cmap='RdBu', vmax=20, vmin=None):
if mp == None:
llcrnrlon = -11.5
llcrnrlat = 23
urcrnrlon = 44
urcrnrlat = 74
mp = bm.Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat, resolution='l')
lon, lat = estimateChngSignificanceAndRobustness.getLonLat()
lon, lat = lon.transpose(), lat.transpose()
plt.axes(ax)
mp.drawcoastlines(linewidth=.25)
mp.fillcontinents(color=[.95, .95, .95], lake_color=[.95, .95, .95], zorder=0)
#mp.drawparallels(np.arange(-180, 180, 10), labels=[1,1])
#mp.drawmeridians(np.arange(-90, 90, 10), labels=[1,1])
pcl = mp.pcolor(lon, lat, relChngDiff*100, cmap=cmap)
vmin = -vmax if vmin is None else vmin
plt.clim(vmin, vmax)
print('mean absolute change: ' + str(np.nanmean(np.abs(relChngDiff)*100)) + '%')
txtpos = mp(-7, 25)
plt.annotate(txt, xy=txtpos, xycoords='data', xytext=txtpos, textcoords='data', fontsize=13)
return pcl, mp
def plot_current_field(uin, vin, lons, lats):
plt.subplot()
# Create map
m = basemap.Basemap(projection='cyl',
resolution='c',
llcrnrlat=-90.,
urcrnrlat=90.,
llcrnrlon=-180.,
urcrnrlon=180.)
m.drawcoastlines()
m.drawparallels(np.arange(-90., 90., 30.),
labels=[1, 0, 0, 0],
fontsize=10)
m.drawmeridians(np.arange(-180., 180., 30.),
labels=[0, 0, 0, 1],
fontsize=10)
# Transform vector and coordinate data
vec_lon = uin.shape[1] // 10
vec_lat = uin.shape[0] // 10
u_rot, v_rot, x, y = m.transform_vector(uin,
vin,
lons,
lats,
vec_lon,
vec_lat,
returnxy=True)
# Create vector plot on map
vec_plot = m.quiver(x, y, u_rot, v_rot, scale=50, width=0.002)
plt.quiverkey(vec_plot, 0.2, -0.2, 1, '1 knot', labelpos='W')
def plot_points(data_path: str, map_margin, area_threshold, fname) -> None:
# load data
data = pd.read_csv(data_path, sep=";")
# get longitudes and latitudes
longitude = data.iloc[:, 0].values
latitude = data.iloc[:, 1].values
# get maxmial an minimal values
max_long = max(longitude)
min_long = min(longitude)
max_lati = max(latitude)
min_lati = min(latitude)
# create map
map_fragment = basemap.Basemap(
projection="merc",
llcrnrlon=min_long - map_margin,
llcrnrlat=min_lati - map_margin,
urcrnrlon=max_long + map_margin,
urcrnrlat=max_lati + map_margin,
resolution="h",
area_thresh=area_threshold,
)
map_fragment.drawcoastlines()
map_fragment.drawcountries()
map_fragment.drawstates()
lons, lats = map_fragment(longitude, latitude)
plt.scatter(lons, lats, marker="o", color="Red", s=1)
plt.savefig(fname=fname, dpi=300)
plt.clf()
def plot_FuncNd(cube2plot, figpath, mnth, nlevc, xstart, xend, ystart, yend,
title_name):
# pdb.set_trace()
# print cube2plot.collapsed(['time', 'latitude','longitude'],iris.analysis.MIN), nlevc
#levels = np.linspace(iris.analysis.MIN(cube2plot),iris.analysis.MAX(cube2plot) , nlevc)
plt.clf()
#levels=np.linspace(282,302,nlevc)
levels = np.linspace(0, 360, nlevc)
#a = np.max(cube2plot[:,:])
#b = np.min(cube2plot[:,:])
#levs = np.linspace(b, a, n)
qplt.contourf(cube2plot, levels=levels, extend='max')
m = bm.Basemap(projection='cyl',
llcrnrlat=ystart,
urcrnrlat=yend,
llcrnrlon=xstart,
urcrnrlon=xend,
resolution='c') # coarse resolution for grid
#m = bm.Basemap(projection='cyl', llcrnrlat=8.0, urcrnrlat=16.0, llcrnrlon=-20.0, urcrnrlon=20.0, resolution='c') # coarse resolution for grid
m.drawcoastlines(linewidth=2)
m.drawcountries(linewidth=1)
plt.title(title_name)
if not os.path.exists(figpath):
os.makedirs(figpath)
plt.savefig(figpath + 'Nb_of_day_year' + str(mnth + 1) + '.png')
plt.show()
#if __name__== '__main__':
# plot_Func(cube2plot,outpath,mnth,nlevc)
#plot_Func(cube2plot,outpath,mnth,nlevc,xstart,xend,ystart,yend)
def plotPvalue(ax, pValue, relChngDiff, mp, txt):
if mp == None:
llcrnrlon = -11.5
llcrnrlat = 23
urcrnrlon = 44
urcrnrlat = 74
mp = bm.Basemap(llcrnrlon=llcrnrlon,
llcrnrlat=llcrnrlat,
urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat,
resolution='l')
lon, lat = estimateChngSignificanceAndRobustness.getLonLat()
lon, lat = lon.transpose(), lat.transpose()
plt.axes(ax)
mp.drawcoastlines(linewidth=.25)
pvl_ = pValue.copy()
pvl_[pvl_ > .5] = np.nan
#pvl_[relChngDiff <= 0] = pvl_[relChngDiff <= 0] - 1
#pvl_[relChngDiff > 0] = 1 - pvl_[relChngDiff > 0]
#pcl = mp.pcolor(lon, lat, pvl_, cmap='Spectral')
#pcl = mp.pcolor(lon, lat, pvl_, cmap='hot', vmin=0, vmax=.5)
txtpos = mp(-7, 27)
plt.annotate(txt,
xy=txtpos,
xycoords='data',
xytext=txtpos,
textcoords='data',
fontsize=13)
return pcl, mp
def doPlotMinDisFreq(ax, futRp, lon, lat, txt, mp):
if mp == None:
#llcrnrlon = -11.5
#llcrnrlat = 23
#urcrnrlon = 44
#urcrnrlat = 74
#llcrnrlon = -25
#llcrnrlat = 31
#urcrnrlon = 37
#urcrnrlat = 71.5
llcrnrlon = -25
llcrnrlat = 25
urcrnrlon = 44
urcrnrlat = 71.5
mp = bm.Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat, resolution='l', projection='lcc', lon_0=-15, lat_1=-15, lat_2=10)
plt.axes(ax)
mp.drawcoastlines(linewidth=.25)
pltvls = np.zeros(futRp.shape)*np.nan
pltvls[futRp <= 20] = 1
pltvls[np.logical_and(futRp > 20, futRp <= 40)] = 2
pltvls[np.logical_and(futRp > 40, futRp <= 70)] = 3
pltvls[np.logical_and(futRp > 70, futRp <= 100)] = 4
pltvls[np.logical_and(futRp > 100, futRp <= 150)] = 5
pltvls[np.logical_and(futRp > 150, futRp <= 250)] = 6
pltvls[np.logical_and(futRp > 250, futRp <= 400)] = 7
pltvls[futRp > 400] = 8
x, y = mp(lon, lat)
sc = plt.scatter(x, y, s=1, c=pltvls, vmin=1, vmax=8, linewidth=0, cmap='bwr')
txtpos = mp(-22, 68)
plt.annotate(txt, xy=txtpos, xycoords='data', xytext=txtpos, textcoords='data', fontsize=19)
return sc, mp
def doPlotAreaMap(ax, chng, mp):
if mp == None:
#llcrnrlon = -11.5
#llcrnrlat = 23
#urcrnrlon = 44
#urcrnrlat = 74
llcrnrlon = -25
llcrnrlat = 31
urcrnrlon = 37
urcrnrlat = 71.5
mp = bm.Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat, resolution='l', projection='lcc', lon_0=-15, lat_1=-15, lat_2=10)
lon, lat = getLonLat()
lon, lat = lon.transpose(), lat.transpose()
cnd = ~np.isnan(chng)
lonFt, latFt = lon[cnd], lat[cnd]
chngFt = chng[cnd]
x, y = mp(lonFt, latFt)
plt.axes(ax)
#clr = 'darkblue' if positiveChanges else 'darkred'
cmap = 'Blues' if positiveChanges else 'Reds'
clr = chngFt.copy()
clr[clr > .2] = .2
plt.scatter(x, y, clr, c=clr, cmap=cmap)
mp.drawcoastlines(linewidth=.25)
mp.fillcontinents(color=[.95, .95, .95], lake_color=[.95, .95, .95], zorder=0)
return mp
def plot_Func_SAT(cube2plot,figpath,mnth,nlevc,xstart,xend,ystart,yend,title_name):
# pdb.set_trace()
# print cube2plot.collapsed(['time', 'latitude','longitude'],iris.analysis.MIN), nlevc
#levels = np.linspace(iris.analysis.MIN(cube2plot),iris.analysis.MAX(cube2plot) , nlevc)
plt.clf()
levels=np.linspace(282,302,nlevc)
levels=np.linspace(8,32,nlevc)
qplt.contourf(cube2plot, levels = levels, extend = 'max')
m = bm.Basemap(projection='cyl', llcrnrlat=ystart, urcrnrlat=yend, llcrnrlon=xstart, urcrnrlon=xend, resolution='c') # coarse resolution for grid
#m = bm.Basemap(projection='cyl', llcrnrlat=8.0, urcrnrlat=16.0, llcrnrlon=-20.0, urcrnrlon=20.0, resolution='c') # coarse resolution for grid
m.drawcoastlines(linewidth=2)
m.drawcountries(linewidth=1)
plt.title(title_name)
if not os.path.exists(figpath):
os.makedirs(figpath)
if mnth == 0:
plt.savefig(figpath +'Seasonal_average_DJF.png' )
plt.show()
if mnth == 1:
plt.savefig(figpath +'Seasonal_average_MAM.png' )
plt.show()
if mnth == 2:
plt.savefig(figpath +'Seasonal_average_JJA.png' )
plt.show()
if mnth == 3:
plt.savefig(figpath +'Seasonal_average_SON.png' )
plt.show()
def doPlotMinDisFreq(ax, futRp, lon, lat, txt, mp):
if mp == None:
#llcrnrlon = -11.5
#llcrnrlat = 23
#urcrnrlon = 44
#urcrnrlat = 74
#llcrnrlon = -25
#llcrnrlat = 31
#urcrnrlon = 37
#urcrnrlat = 71.5
llcrnrlon = -25
llcrnrlat = 25
urcrnrlon = 44
urcrnrlat = 71.5
mp = bm.Basemap(llcrnrlon=llcrnrlon,
llcrnrlat=llcrnrlat,
urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat,
resolution='l',
projection='lcc',
lon_0=-15,
lat_1=-15,
lat_2=10)
plt.axes(ax)
mp.drawcoastlines(linewidth=.25)
#pltvls = np.zeros(futRp.shape)*np.nan
#pltvls[futRp <= 2] = 0
#pltvls[futRp <= 4] = 1
#pltvls[np.logical_and(futRp > 4, futRp <= 8)] = 2
#pltvls[np.logical_and(futRp > 8, futRp <= 14)] = 3
#pltvls[np.logical_and(futRp > 14, futRp <= 20)] = 4
#pltvls[np.logical_and(futRp > 20, futRp <= 30)] = 5
#pltvls[np.logical_and(futRp > 30, futRp <= 50)] = 6
#pltvls[np.logical_and(futRp > 50, futRp <= 80)] = 7
#pltvls[np.logical_and(futRp > 80, futRp <= 150)] = 8
#pltvls[futRp > 150] = 9
#x, y = mp(lon, lat)
#sc = plt.scatter(x, y, s=1, c=pltvls, vmin=1, vmax=8, linewidth=0, cmap='bwr')
x, y = mp(lon, lat)
sc = plt.scatter(x,
y,
s=1,
c=futRp,
vmin=-100,
vmax=100,
linewidth=0,
cmap='bwr_r')
txtpos = mp(-22, 68)
plt.annotate(txt,
xy=txtpos,
xycoords='data',
xytext=txtpos,
textcoords='data',
fontsize=19)
return sc, mp
def plotSigma(ax, sigma, relChngDiff, mp, txt, sigmamax=30, signSigmaThreshold1=1, signSigmaThreshold2=2, prcTxtTmpl='', printSignTxt=True):
if mp == None:
#llcrnrlon = -11.5
#llcrnrlat = 23
#urcrnrlon = 44
#urcrnrlat = 74
llcrnrlon = -25
llcrnrlat = 31
urcrnrlon = 37
urcrnrlat = 71.5
mp = bm.Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat, resolution='l', projection='lcc', lon_0=-15, lat_1=-15, lat_2=10)
lon, lat = estimateChngSignificanceAndRobustness.getLonLat()
lon, lat = lon.transpose(), lat.transpose()
x, y = mp(lon, lat)
plt.axes(ax)
mp.drawcoastlines(linewidth=.25)
mp.fillcontinents(color=[.95, .95, .95], lake_color=[.95, .95, .95], zorder=0)
absSigma = np.abs(sigma)
#pcl = mp.pcolor(lon, lat, sigma, cmap='hot_r', vmin=0, vmax=sigmamax)
#pcl = mp.pcolor(lon, lat, sigma, cmap='Spectral_r', vmin=0, vmax=sigmamax)
#pcl = mp.pcolor(lon, lat, sigma, cmap='coolwarm', vmin=0, vmax=sigmamax)
#pcl = mp.pcolor(lon, lat, np.abs(sigma), cmap='RdBu_r', vmin=0, vmax=sigmamax)
#pcl = mp.pcolor(lon, lat, absSigma, cmap='PuBu_r', vmin=0, vmax=sigmamax)
#pcl = mp.scatter(lon.flatten(), lat.flatten(), .07, c=absSigma.flatten(), cmap='PuBu_r', alpha=1, vmin=0, vmax=sigmamax)
pcl = mp.scatter(x.flatten(), y.flatten(), .07, c=absSigma.flatten(), cmap='Oranges', alpha=1, vmin=0, vmax=sigmamax)
#prcTxtTmpl = '% of pixel where ${thr}\|\Delta Q_{{100-wl}}\| > \sigma_{{im}}$: {p:2.0f}%' if prcTxtTmpl == '' else prcTxtTmpl
if prcTxtTmpl != '':
sigma_ratio = sigma/np.abs(relChngDiff)
percSign = float(np.nansum(sigma_ratio <= signSigmaThreshold1))/np.nansum(np.logical_not(np.isnan(sigma_ratio)))
thrstr = '{thr:1.0f}'.format(thr=signSigmaThreshold1) if signSigmaThreshold1 != 1 else ''
prcTxt1 = prcTxtTmpl.format(p=percSign*100, thr=thrstr)
print(prcTxt1)
percSign = float(np.nansum(sigma_ratio <= signSigmaThreshold2))/np.nansum(np.logical_not(np.isnan(sigma_ratio)))
thrstr = '{thr:1.0f}\cdot'.format(thr=signSigmaThreshold2) if signSigmaThreshold2 != 1 else ''
prcTxt2 = prcTxtTmpl.format(p=percSign*100, thr=thrstr)
print(prcTxt2)
#txtpos = mp(-7, 71)
txtpos = mp(-24, 32) if printSignTxt else mp(-21, 69.5)
plt.annotate(txt, xy=txtpos, xycoords='data', xytext=txtpos, textcoords='data', fontsize=13)
if printSignTxt:
#txtpos = mp(-8, 27)
txtpos = mp(-24.3, 70.3)
bb = {'boxstyle': 'square,pad=0', 'ec': 'none', 'fc': 'w'}
plt.annotate(prcTxt1, xy=txtpos, xycoords='data', xytext=txtpos, textcoords='data', fontsize=10, bbox=bb)
#txtpos = mp(-8, 24)
#txtpos = mp(-24.3, 69.1)
#plt.annotate(prcTxt2, xy=txtpos, xycoords='data', xytext=txtpos, textcoords='data', fontsize=10, bbox=bb)
else:
txtpos = mp(-24, 32)
plt.annotate(txt, xy=txtpos, xycoords='data', xytext=txtpos, textcoords='data', fontsize=13)
return pcl, mp
def _getBaseMap(self, lonlims, latlims):
if self.mp is None:
self._print('generating basemap ...')
mp = bm.Basemap(llcrnrlon = lonlims[0], llcrnrlat = latlims[0], urcrnrlon = lonlims[1], urcrnrlat = latlims[1], resolution = self.cstLineRes)
self.mp = mp
else:
mp = self.mp
return mp
