def test_gshhs(): ax = plt.axes(projection=ccrs.Mollweide()) ax.set_extent([138, 142, 32, 42], ccrs.Geodetic()) ax.stock_img() # Draw coastlines. ax.add_feature(cfeature.GSHHSFeature('coarse', edgecolor='red')) # Draw higher resolution lakes (and test overriding of kwargs) ax.add_feature(cfeature.GSHHSFeature('low', levels=[2], facecolor='green'), facecolor='blue')
def plot_dp(storm, datafile1, datafile2=None): #Single file netCDF reading ncf=datafile1 nco=netCDF4.Dataset(ncf) #Get fields to plot lon=nco.variables['longitude'][:] lat=nco.variables['latitude'][:] timeindays=nco.variables['time'][:] dp=nco.variables['dp'][:] triangles=nco.variables['tri'][:,:] reflon=np.linspace(lon.min(),lon.max(),1000) reflat=np.linspace(lat.min(),lat.max(),1000) #reflon=np.linspace(-80.40, -74.75, 1000) #reflat=np.linspace(32.50, 36.60, 1000) #reflon=np.linspace(-75.70, -71.05, 1000) #reflat=np.linspace(38.50, 41.40, 1000) reflon,reflat=np.meshgrid(reflon,reflat) plt.figure(figsize = [6.4, 3.8]) flatness=0.10 # flatness is from 0-.5 .5 is equilateral triangle triangles=triangles-1 # Correct indices for Python's zero-base tri=Triangulation(lon,lat,triangles=triangles) mask = TriAnalyzer(tri).get_flat_tri_mask(flatness) tri.set_mask(mask) # Loop through each time step and plot results for ind in range(0, len(timeindays)): plt.clf() ax = plt.axes(projection=ccrs.Mercator()) dt = datetime.datetime.combine(datetime.date(1990, 1, 1), datetime.time(0, 0)) + datetime.timedelta(days=timeindays[ind]) dstr = datetime.date.strftime(dt,'%Y%m%d%H:%M:%S') dstr = dstr[0:8]+' '+dstr[8:17] print('Plotting '+dstr) par=np.double(dp[ind,:]) tli=LinearTriInterpolator(tri,par) par_interp=tli(reflon,reflat) plt.pcolormesh(reflon,reflat,par_interp,vmin=0.0,vmax=360.0,shading='flat',cmap=plt.cm.jet, transform=ccrs.PlateCarree()) cb = plt.colorbar() cb.ax.tick_params(labelsize=8) coast = cfeature.GSHHSFeature(scale='high',edgecolor='black',facecolor='none',linewidth=0.25) ax.add_feature(coast) plt.xticks(fontsize=9) plt.yticks(fontsize=9) figtitle = storm.capitalize()+': Peak Dir (deg): '+dstr plt.title(figtitle) dtlabel = datetime.date.strftime(dt,'%Y%m%d%H%M%S') dtlabel = dtlabel[0:8]+'_'+dtlabel[8:14] filenm = 'nsem_'+storm+'_dp_'+dtlabel+'.png' plt.savefig(filenm,dpi=150,bbox_inches='tight',pad_inches=0.1) del(par) del(par_interp)
def plot_world_map(lons, lats, data, metadata, plotpath): # plot generic world map fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) ax.set_extent([-180, 180, -90, 90]) if metadata['var'] == 'wind': vmin = 0 vmax = 12 elif metadata['var'] == 'hs': vmin = 0 vmax = 5.5 else: vmin = np.nanmin(data) vmax = np.nanmax(data) #cmap = 'viridis' #blue to yellow matlab cmap = 'jet' cbarlabel = '%s' % (metadata['var']) plttitle = 'WW3 Plot of variable %s' % (metadata['var']) cs = ax.pcolormesh(lons, lats, data, vmin=vmin, vmax=vmax, cmap=cmap) cb = plt.colorbar(cs, orientation='horizontal', shrink=0.5, pad=.04) cb.set_label(cbarlabel, fontsize=12) plt.title(plttitle) plt.savefig(plotpath) plt.close('all')
def grab_gshhg_features(scale, levels, extent): """Grabs lat/lon coordinates for GSHHG features. Grab geographical feature data from the GSHHG database for a specified extent, level of detail, and resolution. Outputs simple lat/lon coordinates -- useful for plotting backends (like Bokeh) that don't have fancy geo feature integration. Args: scale: A string, can be either f(ull), h(igh), i(ntermediate), l(ow), or c(rap) depending upon the desired resolution. levels: Specify which level(s) of feature to plot; [1] is only coastlines and [1, 2, 3, 4] is everything. extent: Specify [lonmin, lonmax, latmin, latmax] in decimal degrees. Returns: features: A dictionary containing coordinates of geo features (WGS84 lat/lon, decimal degrees). """ unformatted_features = list(cf.GSHHSFeature(scale=scale, levels=levels).intersecting_geometries(extent)) features = {'latitude':[], 'longitude':[]} for feature in unformatted_features: lons = feature.exterior.coords.xy[0].tolist() lats = feature.exterior.coords.xy[1].tolist() features['longitude'].append(lons) features['latitude'].append(lats) return features
def plot_world_map(lons, lats, data, metadata, plotpath): # plot generic world map fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) ax.set_extent([-180, 180, -90, 90]) #vmin = np.nanmin(data) #vmax = np.nanmax(data) vminmax = float(metadata['vminmaxvar']) vmin = -1 * vminmax vmax = vminmax cmap = 'bwr' cbarlabel = '%s' % (metadata['var']) plttitle = '%s' % (metadata['tag']) cs = ax.pcolormesh(lons, lats, data, vmin=vmin, vmax=vmax, cmap=cmap) cb = plt.colorbar(cs, extend='both', orientation='horizontal', shrink=0.5, pad=.04) cb.set_label(cbarlabel, fontsize=12) plt.title(plttitle) plt.savefig(plotpath) plt.close('all')
def plot_world_map(lons, lats, data, metadata, plotpath, screen, lonr, latr, comment): # plot generic world map if screen.upper() == "NO": matplotlib.use('agg') fig = plt.figure(figsize=(12,8)) ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) listWE = lonr.split(',') listSN = latr.split(',') lonBeg = lonS2F(listWE[0]) lonEnd = lonS2F(listWE[1]) latBeg = latS2F(listSN[0]) latEnd = latS2F(listSN[1]) scaleWE = 360/(lonEnd-lonBeg)*10 scaleSN = 180/(latEnd-latBeg)*10 scaleMax = max(scaleWE,scaleSN) ax.set_extent([lonBeg, lonEnd, latBeg, latEnd]) vmax = np.nanmean(data)+np.nanstd(data)*2 vmin = np.nanmean(data)-np.nanstd(data)*2 cmap = 'viridis' cbarlabel = '%s' % (metadata['var']) if comment == '': plttitle = 'Variable: %s' % (metadata['var']) else: plttitle = 'Variable: %s; %s' % (metadata['var'], comment) cs = plt.scatter(lons, lats, c=data, s=scaleMax, cmap=cmap, transform=ccrs.PlateCarree(),vmin=vmin,vmax=vmax) cb = plt.colorbar(cs, orientation='horizontal', shrink=0.5, pad=.04) cb.set_label(cbarlabel, fontsize=12) plt.title(plttitle) if screen.upper() == "NO": plt.savefig(plotpath) plt.close('all') else: plt.show()
def plot_segments(segments=None, mission_name='', poly=None, lat_min=-22.5, lat_max=-20, lon_min=165.5, lon_max=168.5): """ Plot ADCP transects from regions of intres """ ax = add_map(lat_min=lat_min, lat_max=lat_max, lon_min=lon_min, lon_max=lon_max) for ds in segments: ax.plot(ds['lon'], ds['lat'], '.', markersize=2, label='%s_s%s' % (ds.attrs['mission'], ds.attrs['segment_number'])) land = cfeature.GSHHSFeature(scale='intermediate', levels=[1], facecolor=cfeature.COLORS['land']) if poly is not None: ax.add_geometries(poly, ccrs.PlateCarree(), alpha=0.2) plt.title(mission_name) #plt.legend() plt.tight_layout()
def draw_map(): lat_sp = 20 lon_sp = 30 #60 # title_font = 14 label_font = 10 ds = xr.open_dataset(fileout) ilon = ds.lon ilat = ds.lat var = ds['preci'].resample(time="5D").mean() var = var * 3600 * 24 * 1000 #mm/day time = var.indexes['time'].to_datetimeindex() ds = xr.open_dataset( "/home/ys17-19/renql/project/TP_NUDG/analysis/mdata/gtopo30_0.9x1.25.nc" ) phis = ds['PHIS'].sel(lon=ilon, lat=ilat, method="nearest").load() phis = phis / 9.8 # transfer from m2/s2 to m cnlevels = np.arange(1, 18, 1) fcolors = cmaps.precip2_17lev norm = colors.BoundaryNorm(boundaries=cnlevels, ncolors=fcolors.N, extend='both') for nt in range(len(time)): title = 'CESM AMIP %02d-%02d preci (mm/day)' % (time[nt].month, time[nt].day) fig = plt.figure(figsize=(12, 9), dpi=100) axe = plt.axes(projection=ccrs.PlateCarree(central_longitude=180.0)) axe.add_feature(cfeat.GSHHSFeature(levels=[1, 2], edgecolor='k'), linewidth=0.8, zorder=1) axe.set_title(title, fontsize=title_font) cont = axe.contourf(var.lon, var.lat, var[nt, :, :], cnlevels, transform=ccrs.PlateCarree(), cmap=fcolors, extend='both', norm=norm) topo = axe.contour(phis.lon, phis.lat, phis, [1500, 3000], transform=ccrs.PlateCarree(), colors='black', linewidths=1.5) axe.set_yticks(np.arange(lats, latn, lat_sp), crs=ccrs.PlateCarree()) axe.yaxis.set_major_formatter(LatitudeFormatter(degree_symbol='')) axe.set_xticks(np.arange(lonl, lonr, lon_sp), crs=ccrs.PlateCarree()) axe.xaxis.set_major_formatter(LongitudeFormatter(degree_symbol='')) cb = plt.colorbar(cont) plt.savefig('%s%d' % (figdir, nt), bbox_inches='tight', pad_inches=0.01)
def get_map(region=None, zoom=1, projection=ccrs.Mercator(), res='i', draw_coastlines=True, figsize=(8, 10), shape=(1, 1)): extents = [] if isinstance(region, str): region = [region] for r in region: extents.append(extent_from_region(r)) fig, axes = plt.subplots( shape[0], shape[1], figsize=figsize, subplot_kw={ # kwargs passed to add_subplot() 'projection': projection }) if not isinstance(axes, (list, np.ndarray)): axes = [axes] for ax, e in zip(axes, extents): ax.set_extent(e) ax.add_feature(cfeat.GSHHSFeature( scale=res)) if draw_coastlines else False if len(axes) == 1: return fig, axes[0] else: return fig, axes
def plot_world_map(lons, lats, data, metadata, plotpath): # plot generic world map fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) ax.set_extent([-180, 180, -90, 90]) cmap = 'jet' cbarlabel = '%s' % (metadata['var']) plttitle = 'MOM6 Plot of variable %s' % (metadata['var']) if metadata['var'] == 'MLD_003': bounds = np.array([ 10, 20, 30, 40, 50, 60, 80, 100, 150, 200, 250, 300, 400, 500, 1000 ]) norm = mcolors.BoundaryNorm(boundaries=bounds, ncolors=256) cs = ax.pcolormesh(lons, lats, data, norm=norm, cmap=cmap) else: vmin = np.nanmin(data) vmax = np.nanmax(data) cs = ax.pcolormesh(lons, lats, data, vmin=vmin, vmax=vmax, cmap=cmap) cb = plt.colorbar(cs, extend='both', orientation='horizontal', shrink=0.5, pad=.04) cb.set_label(cbarlabel, fontsize=12) plt.title(plttitle) plt.savefig(plotpath) plt.close('all')
def nice_map(dataarray, ax=None, title='', transform=ccrs.PlateCarree(), **kwargs): """ Make a nice map with gridlines and coordinates Parameters ---------- ax: matplotlib axes object, optional If None, uses the current axis title: str, optional Title of the plot """ if ax is None: ax = plt.subplot(1, 1, 1, projection=transform) dataarray.plot.pcolormesh(ax=ax, transform=transform, **kwargs) land = cfeature.GSHHSFeature(scale='intermediate', levels=[1], facecolor=cfeature.COLORS['land']) ax.add_feature(land) ax.set_title(title) gl = ax.gridlines(draw_labels=True) gl.xlabels_top = False gl.ylabels_right = False gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER plt.tight_layout()
def plot_spatial(diag): n = len(diag.diff) mean, std, mx, mn = calculate_stats(diag.diff) plt.figure(figsize=(15,12)) ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) ax.set_extent([-180, 180, -90, 90]) norm = mcolors.BoundaryNorm(boundaries=diag.variables[diag.variable]['boundsize'], ncolors=256) cs = plt.scatter(diag.lons, diag.lats, c=diag.diff, s=30, norm=norm, cmap='bwr', #edgecolors='gray', linewidth=0.25, transform=ccrs.PlateCarree()) if diag.dtype == 'conv' and diag.variable == 'q': t = ('n: %s\nstd: %s\nmean: %s' % (n,np.round(std,6),np.round(mean,6))) ax.text(-175, -70, t, fontsize=16, transform=ccrs.PlateCarree()) else: t = ('n: %s\nstd: %s\nmean: %s\nmax: %s\nmin: %s' % (n,np.round(std,3),np.round(mean,3), np.round(mx,3), np.round(mn,3))) ax.text(-175, -70, t, fontsize=16, transform=ccrs.PlateCarree()) labels = diag.get_labels() cb = plt.colorbar(cs, shrink=0.5, pad=.04, extend='both') cb.set_label(labels[diag.ftype]['xlabel'], fontsize=12) title_split = labels[diag.ftype]['left_title'].split('\n') plt.title("%s\n%s" % (title_split[0], '\n'.join(wrap(title_split[-1], 40))), loc='left', fontsize=14) plt.title(labels[diag.ftype]['right_title'], loc='right', fontweight='semibold', fontsize=14) plt.savefig(labels[diag.ftype]['save_title'], bbox_inches='tight', pad_inches=0.1) return 0
def plt_ref_vertical(figname): f = Dataset(figname, mode='r') print(f) nlon = f.dimensions['lon'].size nlat = f.dimensions['lat'].size lat = f.variables['lats'][:] lon = f.variables['lons'][:] sphum = f.variables['sphum'][:, :, :, :] temp = f.variables['T'][:, :, :, :] f.close() x, y = np.meshgrid(lon, lat) print(x[:, :]) print(y[:, :]) # create figure and axes instances plt.figure(figsize=(15, 12)) ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) # ax.coastlines() ax.set_extent([-180, 180, -90, 90]) # cmap,bounds,norm=ncepy.create_ncep_radar_ref_color_table() # cs=plt.scatter(glat,nlev,c=oref,s=58,cmap=cmap,norm=norm,marker="s",edgecolor='none') # cmap=plt.get_cmap("Greys") data = np.zeros((nlat, nlon)) data[:, :] = temp[0, 0, :, :] print(data) upperbound = np.max(data) lowerbound = np.min(data) bins = (upperbound - lowerbound) / 10.0 clevs = np.arange(lowerbound, upperbound + bins, bins) norm = colors.BoundaryNorm(boundaries=clevs, ncolors=256) #cs=plt.scatter(x,y,c=pres,s=40,cmap=cmap,norm=norm,marker=(verts_function(1,1,0.25),0),edgecolor='none') #cs=plt.scatter(x,y,c=pres,s=40,cmap='bwr',norm=norm,marker="s",edgecolor='none') #cs=plt.scatter(x,y,c=data,s=10,cmap='bwr',norm=norm,transform=ccrs.PlateCarree()) cs = plt.contourf(x, y, data, clevs, cmap='bwr', transform=ccrs.PlateCarree()) cb = plt.colorbar(cs, shrink=0.5, pad=.04, extend='both') cb.ax.tick_params(labelsize=5.0) # plt.ylim([0,60]) # plt.xlim([24,52]) # plt.title(titlename+' latitude CREF',fontsize=25) # clevs=bins # cbar = plt.colorbar(cs,location='bottom',pad=0.05,ticks=clevs) # titlename= plt.savefig('./' + figname + '.png', bbox_inches='tight', dpi=100)
def plot_world_map(tiles, lons, lats, data, metadata, plotpath, screen, lonr, latr, extreme, comment): # plot generic world map if screen.upper() == "NO": matplotlib.use('agg') fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) listWE = lonr.split(',') listSN = latr.split(',') lonBeg = lonS2F(listWE[0]) lonEnd = lonS2F(listWE[1]) latBeg = latS2F(listSN[0]) latEnd = latS2F(listSN[1]) ax.set_extent([lonBeg, lonEnd, latBeg, latEnd]) # dealing with missing values (assuming absolute values > 1.E8) data_new = data.copy() data_new[abs(data) > 1.E8] = np.nan if not extreme == '': strMinMax = extreme.split(',') vmin = float(strMinMax[0]) vmax = float(strMinMax[1]) invalid = np.logical_or( data_new == np.nan, np.logical_or(data_new > vmax, data_new < vmin)) data_new[invalid] = np.nan data_new = np.ma.masked_where(np.isnan(data_new), data_new) vmin = np.nanmin(data_new) vmax = np.nanmax(data_new) #vmax = np.nanmean(data_new)+np.nanstd(data_new)*2 #vmin = np.nanmean(data_new)-np.nanstd(data_new)*2 cmap = 'viridis' cbarlabel = '%s' % (metadata['var']) if comment == '': plttitle = 'Variable: %s' % (metadata['var']) else: plttitle = 'Variable: %s; %s' % (metadata['var'], comment) for t in range(tiles): cs = ax.pcolormesh(lons[..., t], lats[..., t], data_new[..., t], vmin=vmin, vmax=vmax, cmap=cmap) cb = plt.colorbar(cs, orientation='horizontal', shrink=0.5, pad=.04) cb.set_label(cbarlabel, fontsize=12) plt.title(plttitle) if screen.upper() == "NO" or screen.upper() == "ALL": plt.savefig(plotpath) if screen.upper() == "ALL": plt.show() plt.close('all') else: plt.show()
def pltallbuoytracks(loc, BD): Buoys = ['02', '03', '09', '07', '12', '13', '14', '16'] fig = plt.figure(figsize=(12, 12), frameon=True) ax = plt.axes(projection=ccrs.LambertAzimuthalEqualArea( central_longitude=25.0, central_latitude=77.0)) ax.set_extent([16, 28, 74.5, 80]) colors = [ 'red', 'green', 'magenta', 'darkblue', 'lime', 'orange', 'yellow', 'olive' ] fig.canvas.draw() xticks = [0, 4, 12, 16, 20, 24, 28, 32, 36] yticks = [72, 74.5, 77, 79.5, 82] ax.gridlines(xlocs=xticks, ylocs=yticks) # Label the end-points of the gridlines using the custom tick makers: ax.xaxis.set_major_formatter(LONGITUDE_FORMATTER) ax.yaxis.set_major_formatter(LATITUDE_FORMATTER) lambert_xticks(ax, xticks) lambert_yticks(ax, yticks) i = 0 pt = 96 * 1 for b in Buoys: # Plotting b-uoy obs and buoy simulated locations Xib = BD[b + '_x'] Yib = BD[b + '_y'] plt.scatter(Xib[pt], Yib[pt], color='black', transform=ccrs.PlateCarree()) plt.text(Xib[pt], Yib[pt], b, transform=ccrs.PlateCarree(), fontsize=15, fontweight='bold') plt.plot(Xib[pt:], Yib[pt:], color=colors[i], transform=ccrs.PlateCarree(), label=b) i += 1 # gebco wms background service = 'https://www.gebco.net/data_and_products/gebco_web_services/web_map_service/mapserv?' ax.add_wms(service, layers=['GEBCO_LATEST'], wms_kwargs={ 'width': 900 * 2, 'height': 600 * 2 }) feature = cpf.GSHHSFeature(scale='i', levels=[1], facecolor='#e6e1e1', alpha=1) ax.add_feature(feature) plt.savefig(loc + '/allbuoytracks.jpg', format='jpg', dpi=600) plt.close(fig)
def add_map(lon_min=-180, lon_max=180, lat_min=-90, lat_max=90, central_longitude=0., scale='auto', ax=None): """ Add the map to the existing plot using cartopy Parameterss ---------- lon_min : float, optional Western boundary, default is -180 lon_max : float, optional Eastern boundary, default is 180 lat_min : float, optional Southern boundary, default is -90 lat_max : float, optional Northern boundary, default is 90 central_longitude : float, optional Central longitude, default is 180 scale : {‘auto’, ‘coarse’, ‘low’, ‘intermediate’, ‘high, ‘full’}, optional The map scale, default is 'auto' ax : GeoAxes, optional A new GeoAxes will be created if None Returns ------- ax : GeoAxes Return the current GeoAxes instance """ extent = (lon_min, lon_max, lat_min, lat_max) if ax is None: ax = plt.subplot( 1, 1, 1, projection=ccrs.PlateCarree(central_longitude=central_longitude)) ax.set_extent(extent) land = cfeature.GSHHSFeature(scale=scale, levels=[1], facecolor=cfeature.COLORS['land']) ax.add_feature(land) gl = ax.gridlines(draw_labels=True, linestyle=':', color='black', alpha=0.5) gl.xlabels_top = False gl.ylabels_right = False gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER return ax
def land(self, facecolor="white", **kwargs): """ Draw the land mask Parameters ---------- facecolor: string, optional color to draw the mask with **kwargs: additional arguments to add_feature """ self.ax.add_feature(cft.GSHHSFeature(self.res, [1]), facecolor=facecolor, **kwargs)
def plotMap(): #Set the projection information proj = ccrs.PlateCarree() #Create a figure with an axes object on which we will plot. Pass the projection to that axes. fig, ax = plt.subplots(subplot_kw=dict(projection=proj)) #Zoom in img_extent = [140, 162, 34, 50] ax.set_extent(img_extent, crs=proj) #Add map features # ax.add_feature(cfeature.LAND, facecolor='0.9' # ) #Grayscale colors can be set using 0 (black) to 1 (white) land_50m = cfeature.NaturalEarthFeature('physical', 'land', '50m', edgecolor='face', facecolor=cfeature.COLORS['land']) ax.add_feature(land_50m) ax.add_feature( cfeature.LAKES, alpha=0.9) #Alpha sets transparency (0 is transparent, 1 is solid) ax.add_feature(cfeature.BORDERS, zorder=10) # ax.add_feature(cfeature.COASTLINE, zorder=10) gshhs = cfeature.GSHHSFeature(scale='i', levels=None) ax.add_feature(gshhs) #We can use additional features from Natural Earth (http://www.naturalearthdata.com/features/) states_provinces = cfeature.NaturalEarthFeature( category='cultural', name='admin_1_states_provinces_lines', scale='50m', facecolor='none') ax.add_feature(states_provinces, edgecolor='gray', zorder=10) #Add lat/lon gridlines every 20° to the map gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True, linewidth=0.1, alpha=1, linestyle='-') gl.xlabels_top = False gl.ylabels_left = False gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER ax.text(142.2, 43.5, 'Hokkaido', transform=proj) ax.text(140.4, 39.7, 'Honshu', transform=proj) return fig, ax
def coast2wkb(lonmin, lonmax, latmin, latmax, GSHHSres, coastfile): # Global cartopy feature from GSHHS gfeat = cfeature.GSHHSFeature(scale=GSHHSres) # As shapely collection generator coll = gfeat.geometries() # Polygon representation of the regional domain frame = geom.box(lonmin, latmin, lonmax, latmax) # The intersection B = (frame.intersection(p) for p in coll if frame.intersects(p)) # Save to file with open(coastfile, mode='wb') as fp: wkb.dump(geom.MultiPolygon(flatten(B)), fp, output_dimension=2)
def plot_spatial(data, metadata, lats, lons): stats = calculate_stats(data) plt.figure(figsize=(15, 12)) ax = plt.axes(projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) ax.set_extent([-180, 180, -90, 90]) upperbound = (np.round(stats['Std'] * 2) / 2) * 5 lowerbound = 0 - upperbound bins = (upperbound - lowerbound) / 10 norm = mcolors.BoundaryNorm(boundaries=np.arange(lowerbound, upperbound + bins, bins), ncolors=256) cs = plt.scatter( lons, lats, c=data, s=30, norm=norm, cmap='bwr', #edgecolors='gray', linewidth=0.25, transform=ccrs.PlateCarree()) labels = plot_labels(metadata, stats) ax.text(-175, -70, labels['statText'], fontsize=14, transform=ccrs.PlateCarree()) cb = plt.colorbar(cs, shrink=0.5, pad=.04, extend='both') cb.set_label(labels['xLabel'], fontsize=12) plt.title(labels['leftTitle'], loc='left', fontsize=14) plt.title(labels['dateTitle'], loc='right', fontweight='semibold', fontsize=14) plt.savefig('%s_spatial.png' % labels['saveFile'], bbox_inches='tight', pad_inches=0.1) return
def _plot_geographic_context(ax, hires=False): """ Plot geographic basemap information on a map axis. Plots simple coastlines for unprojected plots. Args: ax (:class:`~cartopy.mpl.geoaxes.GeoAxes`): Existing axis to plot into hires (bool): If `True`, use higher-resolution coastlines (default: `False`) """ # Since unprojected grids have regional/global extent, just show the # coastlines and borders if hires: gshhs_scale = 'intermediate' lake_scale = '10m' else: gshhs_scale = 'low' lake_scale = '50m' ax.add_feature( cfeature.GSHHSFeature(scale=gshhs_scale), facecolor=cfeature.COLORS['land'], zorder=0, ) ax.background_patch.set_facecolor(cfeature.COLORS['water']) ax.add_feature( cfeature.LAKES.with_scale(lake_scale), facecolor=cfeature.COLORS['water'], edgecolor='black', zorder=0, ) # Add states and provinces borders states_provinces = cfeature.NaturalEarthFeature( category='cultural', name='admin_1_states_provinces_lines', scale='50m', facecolor='none') ax.add_feature(states_provinces, edgecolor='gray') ax.add_feature(cfeature.BORDERS, edgecolor='gray') # Add gridlines and labels ax.gridlines(draw_labels=["x", "y", "left", "bottom"], linewidth=1, color='gray', alpha=0.5, linestyle='--')
def no_data_spatial(metadata, outDir='./'): fig = plt.figure(figsize=(15,12)) ax = fig.add_subplot(1, 1, 1, projection=ccrs.PlateCarree(central_longitude=0)) ax.add_feature(cfeature.GSHHSFeature(scale='auto')) ax.set_extent([-180, 180, -90, 90]) stats = None labels = plot_labels(metadata, stats) ax.text(0,0, 'No Data', fontsize=32, alpha=0.6, ha='center') plt.title(labels['leftTitle'], loc='left', fontsize=14) plt.title(labels['dateTitle'], loc='right', fontweight='semibold', fontsize=14) plt.savefig(outDir+'/%s_spatial.png' % labels['saveFile'], bbox_inches='tight', pad_inches=0.1) plt.close('all') return
def plticepos(Xib, Yib, Xis, Yis, path): fig = plt.figure(figsize=(12, 12), frameon=True) ax = plt.axes(projection=ccrs.LambertAzimuthalEqualArea( central_longitude=25.0, central_latitude=77.0)) # ax.set_extent([15,33,74,81]) ax.set_extent([16, 28, 74, 78]) # Define gridline locations and draw the lines using cartopy's built-in gridliner: # *must* call draw in order to get the axis boundary used to add ticks: fig.canvas.draw() xticks = [0, 4, 12, 16, 20, 24, 28, 32, 36] yticks = [72, 74, 76, 78, 80, 82] ax.gridlines(xlocs=xticks, ylocs=yticks) # Label the end-points of the gridlines using the custom tick makers: ax.xaxis.set_major_formatter(LONGITUDE_FORMATTER) ax.yaxis.set_major_formatter(LATITUDE_FORMATTER) lambert_xticks(ax, xticks) lambert_yticks(ax, yticks) # Plotting buoy obs and buoy simulated locations plt.plot(Xib, Yib, color='red', transform=ccrs.PlateCarree(), label='buoy drift') plt.plot(Xis, Yis, '--', color='yellow', transform=ccrs.PlateCarree(), label='simulated ice drift') # gebco wms background service = 'https://www.gebco.net/data_and_products/gebco_web_services/web_map_service/mapserv?' ax.add_wms(service, layers=['GEBCO_LATEST'], wms_kwargs={ 'width': 900 * 2, 'height': 600 * 2 }) feature = cpf.GSHHSFeature(scale='i', levels=[1], facecolor='#e6e1e1', alpha=1) ax.add_feature(feature) plt.legend(prop={"size": 16}, framealpha=1) plt.savefig(path + '/ice_drift.jpg', dpi=400) plt.close(fig)
def _plot_geographic_context(ax, utm, hires=False): """ Plot geographic basemap information on a map axis. Plots a background image for UTM-projected plots and simple coastlines for unprojected plots. Args: ax (:class:`~cartopy.mpl.geoaxes.GeoAxes`): Existing axis to plot into utm (bool): Flag specifying if the axis is projected to UTM or not hires (bool): If `True`, use higher-resolution images/coastlines (default: `False`) """ # Since projected grids cover less area and may not include coastlines, # use a background image to provide geographical context (can be slow) if utm: if hires: zoom_level = 12 else: zoom_level = 8 ax.add_image(Stamen(style='terrain-background'), zoom_level) # Since unprojected grids have regional/global extent, just show the # coastlines else: if hires: gshhs_scale = 'intermediate' lake_scale = '10m' else: gshhs_scale = 'low' lake_scale = '50m' ax.add_feature( cfeature.GSHHSFeature(scale=gshhs_scale), facecolor=cfeature.COLORS['land'], zorder=0, ) ax.background_patch.set_facecolor(cfeature.COLORS['water']) ax.add_feature( cfeature.LAKES.with_scale(lake_scale), facecolor=cfeature.COLORS['water'], edgecolor='black', zorder=0, )
def plot(self, fscale=10): import matplotlib.pyplot as plt import cartopy.crs as ccrs import cartopy.feature as cfeature import cartopy.mpl.ticker as cticker from shapely.geometry import MultiPoint from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER # First set some plot parameters: bbox = self.bbox(buffer=0.1) minLon, minLat, maxLon, maxLat = bbox extents = [minLon, maxLon, minLat, maxLat] # create figure and plot/map fig, ax = plt.subplots(1, 1, figsize=(fscale, fscale * (maxLon - minLon) / (maxLat - minLat)), subplot_kw={'projection': ccrs.PlateCarree()}) ax.set_extent(extents, crs=ccrs.PlateCarree()) coastline = cfeature.GSHHSFeature(scale='auto', edgecolor='black', facecolor=cfeature.COLORS['land']) ax.add_feature(coastline, zorder=0) ax.add_feature(cfeature.BORDERS, linewidth=2) gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True, linewidth=2, color='gray', alpha=0.5, linestyle='--') gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER # Plot the model domain bx, by = self.boundary_points() poly = plt.Polygon(list(zip(bx, by)), facecolor='r', alpha=0.05) ax.add_patch(poly) ax.plot(bx, by, lw=2, color='k') return fig, ax
def scatter(ds, color, minLon=None, minLat=None, maxLon=None, maxLat=None, fscale=10): import matplotlib.pyplot as plt from mpl_toolkits.axes_grid1.inset_locator import inset_axes from datetime import datetime import cartopy.crs as ccrs import cartopy.feature as cfeature import cartopy.mpl.ticker as cticker from shapely.geometry import MultiPoint from cartopy.mpl.gridliner import LONGITUDE_FORMATTER, LATITUDE_FORMATTER # First set some plot parameters: if not minLon: minLon = ds.LONGITUDE.min().values.item() if not minLat: minLat = ds.LATITUDE.min().values.item() if not maxLon: maxLon = ds.LONGITUDE.max().values.item() if not maxLat: maxLat = ds.LATITUDE.max().values.item() extents = [minLon, maxLon, minLat, maxLat] # create figure and plot/map fig, ax = plt.subplots(1, 1, figsize=(fscale, fscale * (maxLon - minLon) / (maxLat - minLat)), subplot_kw={'projection': ccrs.PlateCarree()}) ax.set_extent(extents, crs=ccrs.PlateCarree()) coastline = cfeature.GSHHSFeature(scale='auto', edgecolor='black', facecolor=cfeature.COLORS['land']) ax.add_feature(coastline, zorder=0) ax.add_feature(cfeature.BORDERS, linewidth=2) gl = ax.gridlines(crs=ccrs.PlateCarree(), draw_labels=True, linewidth=2, color='gray', alpha=0.5, linestyle='--') gl.xformatter = LONGITUDE_FORMATTER gl.yformatter = LATITUDE_FORMATTER if 'PARTITION' in ds: sc = ax.scatter( [ds.sel(PARTITION=part).LONGITUDE for part in ds.PARTITION], [ds.sel(PARTITION=part).LATITUDE for part in ds.PARTITION], c=[ds.sel(PARTITION=part)[color] for part in ds.PARTITION]) else: sc = ax.scatter(ds.LONGITUDE, ds.LATITUDE, c=ds[color]) axins0 = inset_axes(ax, width="5%", height="100%", loc='lower left', bbox_to_anchor=(1.07, 0, 1, 1), bbox_transform=ax.transAxes) cb = fig.colorbar(sc, orientation='vertical', cax=axins0, ticklocation='right') if color == 'TIME': cb.ax.set_yticklabels([ (datetime.fromtimestamp(i // 10**9)).strftime('%b %d %Y') for i in cb.get_ticks() ]) if 'units' in ds[color].attrs.keys(): cb.set_label(f"{ds[color].standard_name}\n [{ds[color].units}]") return fig, ax
def Z500_VEL(datetime, steps=0, model= "MEPS", domain_name = None, domain_lonlat = None, legend=False, info = False,grid=True): for dt in datetime: #modelrun at time.. date = dt[0:-2] hour = int(dt[-2:]) param_sfc = ["air_pressure_at_sea_level", "surface_geopotential"] param_pl = ["air_temperature_pl", "geopotential_pl"] #"air_temperature_2m", param_sfx = ["SST","SIC"] #add later p_levels = [850,1000] param = param_sfc + param_pl split = False print("\n######## Checking if your request is possible ############") try: check_all = check_data(date=dt, model=model, param=param, levtype="pl", p_level=p_levels, step=steps) check_sfx = check_data(date=dt, model=model, param=param_sfx, step=steps) except ValueError: split = True try: print("--------> Splitting up your request to find match ############") check_sfc = check_data(date=dt, model=model, param=param_sfc) check_pl = check_data(date=dt, model=model, param=param_pl, levtype="pl", p_level=p_levels) check_sfx = check_data(date=dt, model=model, param=param_sfx) print(check_pl.file) except ValueError: print("!!!!! Sorry this plot is not availbale for this date. Try with another datetime !!!!!") break print("--------> Found match for your request ############") if not split: file_all = check_all.file.loc[0] data_domain = domain_input_handler(dt, model,domain_name, domain_lonlat, file_all) #lonlat = np.array(data_domain.lonlat) dmap_meps = get_data(model=model, data_domain=data_domain, param=param, file=file_all, step=steps, date=dt, p_level=p_levels) dmap_mepsdfx = get_data(model=model, data_domain=data_domain, param=param_sfx, file=check_sfx.file.loc[0], step=steps,date=dt) print("\n######## Retrieving data ############") print(f"--------> from: {dmap_meps.url} ") dmap_meps.retrieve() tmap_meps = dmap_meps # two names for same value, no copying done. dmap_mepsdfx.retrieve() else: # get sfc level data file_sfc = check_sfc.file.loc[0] data_domain = domain_input_handler(dt, model,domain_name, domain_lonlat, file_sfc) #lonlat = np.array(data_domain.lonlat) dmap_meps = get_data(model=model, param=param_sfc, file=file_sfc, step=steps, date=dt, data_domain=data_domain) print("\n######## Retrieving data ############") print(f"--------> from: {dmap_meps.url} ") dmap_meps.retrieve() # get pressure level data file_pl = check_pl.file.loc[0] tmap_meps = get_data(model=model, data_domain=data_domain, param=param_pl, file=file_pl, step=steps, date=dt, p_level=p_levels) print("\n######## Retrieving data ############") print(f"--------> from: {tmap_meps.url} ") tmap_meps.retrieve() dmap_mepsdfx = get_data(model=model, data_domain=data_domain, param=param_sfx, file=check_sfx.file.loc[0], step=steps, date=dt) dmap_mepsdfx.retrieve() #CALCULATE pt = potential_temperatur(dmap_meps.air_temperature_pl, dmap_meps.pressure*100.) pt_sst = potential_temperatur(dmap_mepsdfx.SST, dmap_meps.air_pressure_at_sea_level[:,0,:,:]) dpt = pt[:,np.where(dmap_meps.pressure==1000)[0],:,:]-pt[:,np.where(dmap_meps.pressure==850)[0],:,:] dpt_sst =pt_sst[:,:,:] - pt[:,np.where(dmap_meps.pressure==850)[0],:,:].squeeze() #dpt_sst =abs(pt_sst[:,:,:] - pt[:,np.where(dmap_meps.pressure==850)[0],:,:].squeeze()) # convert fields dmap_meps.air_pressure_at_sea_level/=100 tmap_meps.geopotential_pl/=10.0 lon0 = dmap_meps.longitude_of_central_meridian_projection_lambert lat0 = dmap_meps.latitude_of_projection_origin_projection_lambert parallels = dmap_meps.standard_parallel_projection_lambert # setting up projection # setting up projection globe = ccrs.Globe(ellipse='sphere', semimajor_axis=6371000., semiminor_axis=6371000.) crs = ccrs.LambertConformal(central_longitude=lon0, central_latitude=lat0, standard_parallels=parallels, globe=globe) for tim in np.arange(np.min(steps), np.max(steps)+1, 1): fig1, ax1 = plt.subplots(1, 1, figsize=(7, 9), subplot_kw={'projection': crs}) ttt = tim #+ np.min(steps) tidx = tim - np.min(steps) print('Plotting {0} + {1:02d} UTC'.format(dt, ttt)) plev2 = 0 embr = 0 ZS = dmap_meps.surface_geopotential[tidx, 0, :, :] MSLP = np.where(ZS < 3000, dmap_meps.air_pressure_at_sea_level[tidx, 0, :, :], np.NaN).squeeze() Z = (tmap_meps.geopotential_pl[tidx, plev2, :, :]).squeeze() DELTAPT=dpt[tidx, 0, :, :] DELTAPT = dpt_sst[tidx,:,:] ICE = dmap_mepsdfx.SIC[tidx, :, :] DELTAPT = np.where( ICE <= 0.99,DELTAPT,0) lvl = range(-1,13) C = [[255,255,255 ], # grey #[255,255,255],#gre [204,191,189 ], # grey [155,132,127 ], # grey [118,86,80], # lillac, 39 64 197 149,53,229 [138,109,81], # blue dark,7,67,194 [218,81,14], [181,165,102], # [229,226,124], ## [213,250,128], [125,231,111], [55,212,95], [25,184,111], [17,138,234], [21,82,198], [37,34,137]] C = np.array(C) C = np.divide(C, 255.) # RGB has to be between 0 and 1 in python CF_prec = plt.contourf(dmap_meps.x, dmap_meps.y, DELTAPT, zorder=0, antialiased=True,extend = "max", levels=lvl, colors=C, vmin=0, vmax=12)# CF_ice = plt.contour(dmap_meps.x, dmap_meps.y, ICE, zorder=1, linewidths=2.5, colors="black", levels=[0.1, 0.5]) # # MSLP with contour labels every 10 hPa C_P = ax1.contour(dmap_meps.x, dmap_meps.y, MSLP, zorder=1, alpha=1.0, levels=np.arange(round(np.nanmin(MSLP), -1) - 10, round(np.nanmax(MSLP), -1) + 10, 1), colors='grey', linewidths=0.5) C_P = ax1.contour(dmap_meps.x, dmap_meps.y, MSLP, zorder=2, alpha=1.0, levels=np.arange(round(np.nanmin(MSLP), -1) - 10, round(np.nanmax(MSLP), -1) + 10, 10), colors='grey', linewidths=1.0) ax1.clabel(C_P, C_P.levels, inline=True, fmt="%3.0f", fontsize=10) #CS = ax1.contour(dmap_meps.x, dmap_meps.y, Z, zorder=3, alpha=1.0, # levels=np.arange(4600, 5800, 20), colors="blue", linewidths=0.7) #ax1.clabel(CS, CS.levels, inline=True, fmt="%4.0f", fontsize=10) ax1.add_feature(cfeature.GSHHSFeature(scale='intermediate')) # ‘auto’, ‘coarse’, ‘low’, ‘intermediate’, ‘high, or ‘full’ (default is ‘auto’). ax1.text(0, 1, "{0}_CAOi_{1}+{2:02d}".format(model, dt, ttt), ha='left', va='bottom', transform=ax1.transAxes, color='black') ########################################################## legend=True if legend: proxy = [plt.axhline(y=0, xmin=1, xmax=1, color="grey"), plt.axhline(y=0, xmin=1, xmax=1, color="black",linewidth=4)] try: ax_cb = adjustable_colorbar_cax(fig1, ax1) plt.colorbar(CF_prec,cax = ax_cb, fraction=0.046, pad=0.01, aspect=25, label=r"$\theta_{SST}-\theta_{850}$", extend="both") except: pass lg = ax1.legend(proxy, [f"MSLP [hPa]", f"Sea ice at 10%, 80%, 99%"]) frame = lg.get_frame() frame.set_facecolor('white') frame.set_alpha(1) make_modelrun_folder = setup_directory(OUTPUTPATH, "{0}".format(dt)) if grid: nicegrid(ax=ax1) if domain_name != model and data_domain != None: # weird bug.. cuts off when sees no data value ax1.set_extent(data_domain.lonlat) print("filename: "+make_modelrun_folder + "/{0}_{1}_CAOi_{2}+{3:02d}.png".format(model, domain_name, dt, ttt)) fig1.savefig(make_modelrun_folder + "/{0}_{1}_CAOi_{2}+{3:02d}.png".format(model, domain_name, dt, ttt), bbox_inches="tight", dpi=200) ax1.cla() plt.clf() plt.close(fig1) plt.close("all")
def plot2d_bias(cfg, plot_params): """Plot 2d maps of the bias relative to climatology. Parameters ---------- model_filenames:OrderedDict OrderedDict with model names as keys and input files as values. cmor_var: str name of the variable depth: int we will plot the data on the model level that is closest to the `depth`. diagworkdir: str path to the working directory diagplotdir: str path to the plot directory levels: tuple values to be used for vmin and vmax in the form of (vmin, vmax) dpi: int the dpi values to save the figure observations: str name of the observations projection: instance of cartopy projection (ccrs) bbox: list bounding box. It will be the input for cartopy `set_extent`. ncols: int number of columns. Retuns ------ None """ # setupa a base figure figure, axis = create_plot(plot_params['model_filenames'], ncols=plot_params['ncols'], projection=plot_params['projection']) # get the filename of observations ifilename_obs = genfilename(cfg['work_dir'], plot_params['variable'], plot_params['observations'], data_type='timmean', extension='.nc') # get the metadata for observations (we just need a size) metadata = load_meta( datapath=plot_params['model_filenames'][plot_params['observations']], fxpath=None) lon2d = metadata['lon2d'] # Create an empty array to store the mean. # One point larger along long to acount for cyclic point model_mean = np.zeros((lon2d.shape[0], lon2d.shape[1] + 1)) print("MODEL MEAN SHAPE {}".format(model_mean.shape)) # delete observations from the model list model_filenames = plot_params['model_filenames'].copy() del model_filenames[plot_params['observations']] # loop over models index = None for index, mmodel in enumerate(model_filenames): logger.info("Plot plot2d_bias %s for %s", plot_params['variable'], mmodel) # get the filename with the mean generated by the `timemean` ifilename = genfilename(cfg['work_dir'], plot_params['variable'], mmodel, data_type='timmean', extension='.nc') # do the interpolation to the observation grid # the output is lonc, latc, target_depth, data_obs, interpolated = interpolate_esmf( ifilename_obs, ifilename, plot_params['depth'], plot_params['variable']) # get the label and convert data if needed cb_label, data_obs = label_and_conversion(plot_params['variable'], data_obs) cb_label, interpolated = label_and_conversion(plot_params['variable'], interpolated) # add to the mean model model_mean = model_mean + interpolated # set the map extent left, right, down, upper = plot_params['bbox'] axis[index].set_extent([left, right, down, upper], crs=ccrs.PlateCarree()) # Only pcolormesh is working for now with cartopy, # contourf is failing to plot curvilinear meshes, # let along the unstructures ones. image = axis[index].contourf( lonc, latc, interpolated - data_obs, levels=plot_params['levels'], extend='both', # vmin=contours[0], # vmax=contours[-1], transform=ccrs.PlateCarree(), cmap=plot_params['cmap'], ) # fill continents axis[index].add_feature( cfeature.GSHHSFeature(levels=[1], scale="low", facecolor="lightgray")) axis[index].set_title("{}, {} m".format(mmodel, int(target_depth)), size=18) axis[index].set_rasterization_zorder(-1) # calculate the model mean and plot it if index: index = index else: index = 0 model_mean = model_mean / len(model_filenames) axis[index + 1].set_extent([left, right, down, upper], crs=ccrs.PlateCarree()) image = axis[index + 1].contourf( lonc, latc, model_mean - data_obs, levels=plot_params['levels'], extend='both', # vmin=contours[0], # vmax=contours[-1], transform=ccrs.PlateCarree(), cmap=cmo.balance, ) axis[index + 1].add_feature( cfeature.GSHHSFeature(levels=[1], scale="low", facecolor="lightgray")) axis[index + 1].set_title("Model mean bias, {} m".format( int(target_depth)), size=18) axis[index + 1].set_rasterization_zorder(-1) # delete the axis that are not needed for delind in range(index + 2, len(axis)): figure.delaxes(axis[delind]) # set common colorbar colorbar = figure.colorbar(image, orientation='horizontal', ax=axis, pad=0.01, shrink=0.9) colorbar.set_label(cb_label, rotation='horizontal', size=18) colorbar.ax.tick_params(labelsize=18) # save the picture pltoutname = genfilename(cfg['plot_dir'], plot_params['variable'], "MULTIMODEL", data_type='plot2d_bias_{}_level'.format( str(int(target_depth)))) plot_params['basedir'] = cfg['plot_dir'] plot_params['ori_file'] = [ifilename] plot_params['areacello'] = None plot_params['mmodel'] = None plot_params['region'] = "Global" plt.savefig(pltoutname, dpi=plot_params['dpi']) provenance_record = get_provenance_record(plot_params, 'plot2d_bias', 'png') with ProvenanceLogger(cfg) as provenance_logger: provenance_logger.log(pltoutname + '.png', provenance_record)
def main(): """ lon0 = 35.25; lat0 = -23.60 lon1 = 35.25; lat1 = -24.0 lon2 = 35.65; lat2 = -24.0 lon3 = 35.65; lat3 = -23.60 https://stackoverflow.com/questions/52356926/how-to-set-offset-for-python-cartopy-geometry """ # Create the figure fig = plt.figure(figsize=(5,6)) from cartopy.io.img_tiles import OSM # Add OSM image as background for the selected extension tiler = OSM() ax = plt.axes(projection=tiler.crs) # Openstreet layer zoom detail zoom=12 ax.add_image(tiler, zoom, alpha=0.75) extent = [35.25, 35.65, -24.05, -23.60] ax.set_extent(extent) # Set figure title ax.set_title('Study area',fontsize=10) # Plot coastline from GSHHSF coast_line=cfeature.GSHHSFeature(scale='full') ax.add_feature(coast_line, alpha=1.0, linewidths=0.5, edgecolor='black' ) plotWetlands(ax) plotRivers(ax) plotInterestPoint(ax) # plot difters track plotTrack(ax) # Plot escale bar scaleBar(ax, length=10, location=(0.8, 0.80), linewidth=1.5) plotGridLines(ax) # Criate a subfigure #subfigure = [.58, .09, .30, .20] ax2 = fig.add_axes([.58, .09, .30, .20]) plotMozambique(ax2) # Adjust plot the the figure plt.tight_layout() plt.show() saveFig(fig, file='estudyarea')
def plot2d_original_grid(cfg, plot_params): """Plot 2d maps on original grid using cartopy. Parameters ---------- model_filenames:OrderedDict OrderedDict with model names as keys and input files as values. cmor_var: str name of the variable depth: int we will plot the data on the model level that is closest to the `depth`. Ignored if explicit_depths is provided. levels: tuple values to be used for vmin and vmax in the form of (vmin, vmax) diagworkdir: str path to the working directory diagplotdir: str path to the plot directory cmap: matplotlib colormap colormap dpi: int the dpi values to save the figure explicit_depths: dict Output of the `aw_core` function. It's a dictionary where for each model there is a maximum temperature, depth level in the model, index of the depth level in the model. If provided the `depth` parameter is excluded. projection: instance of cartopy projection (ccrs) bbox: list bounding box. It will be the input for cartopy `set_extent`. ncols: int number of columns. Retuns ------ None """ figure, axis = create_plot(plot_params['model_filenames'], ncols=plot_params['ncols'], projection=plot_params['projection']) index = None for index, mmodel in enumerate(plot_params['model_filenames']): logger.info("Plot plot2d_original_grid %s for %s", plot_params['variable'], mmodel) ifilename = genfilename(cfg['work_dir'], plot_params['variable'], mmodel, data_type='timmean', extension='.nc') metadata = load_meta(ifilename, fxpath=None) datafile = metadata['datafile'] lon2d = metadata['lon2d'] lat2d = metadata['lat2d'] lev = metadata['lev'] if not plot_params['explicit_depths']: depth_target, level_target = closest_depth(lev, plot_params['depth']) else: level_target = plot_params['explicit_depths'][mmodel][ 'maxvalue_index'] depth_target = lev[level_target] if datafile.variables[plot_params['variable']].ndim < 4: data = datafile.variables[plot_params['variable']][ level_target, :, :] else: data = datafile.variables[plot_params['variable']][ 0, level_target, :, :] cb_label, data = label_and_conversion(plot_params['variable'], data) left, right, down, upper = plot_params['bbox'] axis[index].set_extent([left, right, down, upper], crs=ccrs.PlateCarree()) # Only pcolormesh is working for now with cartopy, # contourf is failing to plot curvilinear meshes, # let along the unstructures ones. image = axis[index].pcolormesh( lon2d, lat2d, data, vmin=plot_params['levels'][0], vmax=plot_params['levels'][-1], transform=ccrs.PlateCarree(), cmap=plot_params['cmap'], ) axis[index].add_feature( cfeature.GSHHSFeature(levels=[1], scale="low", facecolor="lightgray")) axis[index].set_title("{}, {} m".format(mmodel, np.round(depth_target, 1)), size=18) axis[index].set_rasterization_zorder(-1) # delete unused axis for delind in range(index + 1, len(axis)): figure.delaxes(axis[delind]) # set common colorbar colorbar = figure.colorbar(image, orientation='horizontal', ax=axis, pad=0.01, shrink=0.9) colorbar.set_label(cb_label, rotation='horizontal', size=18) colorbar.ax.tick_params(labelsize=18) if not plot_params['explicit_depths']: plot_type = 'plot2d_{}_depth'.format(str(plot_params['depth'])) else: plot_type = "plot2d_different_levels" # save the figure pltoutname = genfilename(cfg['plot_dir'], plot_params['variable'], "MULTIMODEL", data_type=plot_type) plot_params['basedir'] = cfg['plot_dir'] plot_params['ori_file'] = [ifilename] plot_params['areacello'] = None plot_params['mmodel'] = None plot_params['region'] = "Global" plt.savefig(pltoutname, dpi=plot_params['dpi']) provenance_record = get_provenance_record(plot_params, 'plot2d', 'png') with ProvenanceLogger(cfg) as provenance_logger: provenance_logger.log(pltoutname + '.png', provenance_record)