def map_imager_track(imager_lonlat, track_lonlat): """ Plot *imager_lonlat* and *track_lonlat* on global map and return the figure. """ from mpl_toolkits.basemap import Basemap fig = figure() ax = fig.add_subplot(111) m = Basemap(projection='cyl', llcrnrlon=-180, llcrnrlat=-90, urcrnrlon=180, urcrnrlat=90, resolution='l', ax=ax) m.drawcoastlines(linewidth=.5, color='grey') # Don't draw each pixel, or the machine will choke! npixels = imager_lonlat[0].size from math import sqrt step = int(round(sqrt(npixels / 1e5))) # Will give a total of about 1e5 pixels _slice_2d = (slice(None, None, step),) * 2 m.pcolormesh(imager_lonlat[0][_slice_2d], imager_lonlat[1][_slice_2d], imager_lonlat[1][_slice_2d], alpha=.5) m.plot(track_lonlat[0], track_lonlat[1], 'o', markersize=1, alpha=.1, label='track') return fig
def plot_drainage_areas(path = "data/hydrosheds/test_using_splitting_amno.nc"): ds = Dataset(path) #basemap = polar_stereographic.basemap basemap = Basemap() lons = ds.variables["lon"][:] lats = ds.variables["lat"][:] channel_slope = ds.variables["slope"][:] lons[lons < 0] += 360 x, y = basemap(lons, lats) acc_area = ds.variables["accumulation_area"][:] acc_area = np.log(acc_area) acc_area = np.ma.masked_where(channel_slope < 0, acc_area) basemap.pcolormesh(x, y, acc_area) basemap.drawcoastlines() plt.colorbar() plt.xlim(x.min(), x.max()) plt.ylim(y.min(), y.max()) plt.show()
def do_subplot(field, title, lons, lats, plot_num, pole, diff=False): """ Make an individual subplot. """ if pole == 'north': projection = 'nplaea' boundinglat = 50 else: projection = 'splaea' boundinglat = -50 m_base = Basemap(projection=projection, boundinglat=boundinglat, lon_0=0) x, y = m_base(lons, lats) ax = fig.add_subplot(plot_num) max = get_max_within_area(field, lats, boundinglat, pole) if diff: cmap = plt.get_cmap('RdBu_r') min = -max else: cmap = plt.get_cmap() min = 0 # Set the land points to be gray. cmap.set_bad('0.65') m_base.pcolormesh(x, y, field, vmax=max, vmin=min, cmap=cmap) m_base.colorbar() m_base.drawparallels(np.arange(-80.,81.,20.)) m_base.drawmeridians(np.arange(-180.,181.,20.)) if title: plt.title(title)
def diagnose_mean(): path = "/home/huziy/skynet1_rech3/cordex/for_Samira/Africa_0.44deg_ERA40-Int1.5_E21981-2010/dailyAfrica_0.44deg_ERA40-Int1.5_E21981-2010TRAF.nc" ds = nc.Dataset(path) traf = ds.variables["TRAF"][:,0,:,:] traf_m = np.mean(traf, axis = 0) * 24 *60 * 60 * 365 #transform to mm/day lon = ds.variables["longitude"][:] lat = ds.variables["latitude"][:] lon[lon > 180] -= 360 levels = [0,0.1,1,5,10,25, 50,100, 200, 300, 600, 1000,1500,2000,2500,3000,5000] cMap = get_cmap("jet", len(levels) - 1 ) bn = BoundaryNorm(levels, cMap.N) ll_lon, ur_lon = np.min(lon), np.max(lon) ll_lat, ur_lat = np.min(lat), np.max(lat) traf_min = 0.1 traf_m = np.ma.masked_where(traf_m < traf_min, traf_m) import matplotlib.pyplot as plt b = Basemap(projection="merc",llcrnrlon=ll_lon, llcrnrlat=ll_lat, urcrnrlon=ur_lon, urcrnrlat=ur_lat) x,y = b(lon, lat) plt.figure() b.pcolormesh(x, y, traf_m, norm = bn, cmap = cMap) cb = plt.colorbar() cb.ax.set_title("mm/year") b.drawcoastlines() plt.show()
def basemapPGAPlot(lons, lats, pga): lonmesh, latmesh = np.meshgrid(lons, lats) pga = np.array(pga) pga = pga.reshape((len(lons), len(lats))) plt.close() m = Basemap(projection='cyl', llcrnrlat=lats.min(), urcrnrlat=lats.max(), llcrnrlon=lons.min(), urcrnrlon=lons.max(), resolution='i') m.drawcoastlines() #m.drawmapboundary(fill_color='PaleTurquoise') #m.fillcontinents(color='lemonchiffon',lake_color='PaleTurquoise', zorder=0) m.drawmapboundary()#fill_color='lightgray') #m.fillcontinents(color='darkgray',lake_color='lightgray', zorder=0) m.drawcountries() m.drawparallels(np.arange(round(lats.min()),round(lats.max()),2), labels=[1,0,0,0]) m.drawmeridians(np.arange(round(lons.min()),round(lons.max()),2), labels=[0,0,0,1]) #m.contourf(lonmesh, latmesh, pga) #m.plot(simx[::], simy[::], 'm.') m.pcolormesh(lonmesh, latmesh, pga, vmin = 0, vmax = 20, cmap="jet") cb = m.colorbar() cb.set_label("Peak Ground Acceleration (% g)") m.show()
def plot_on_earth(lons, lats, data, vmin=-4, vmax=12, cbar_loc='left', cbar_ticks=None): #import ipdb; ipdb.set_trace() #if ax == None: #ax = plt.gca() plot_lons, plot_data = extend_data(lons, lats, data) lons, lats = np.meshgrid(plot_lons, lats) m = Basemap(projection='cyl', resolution='c', llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180) x, y = m(lons, lats) m.pcolormesh(x, y, plot_data, vmin=vmin, vmax=vmax) #m.pcolormesh(x, y, plot_data) m.drawcoastlines() if cbar_loc == 'left': p_labels = [0, 1, 0, 0] else: p_labels = [1, 0, 0, 0] m.drawparallels(np.arange(-90.,90.1,45.), labels=p_labels, fontsize=10) m.drawmeridians(np.arange(-180.,180.,60.), labels=[0, 0, 0, 1], fontsize=10) #import ipdb; ipdb.set_trace() if cbar_ticks == None: cbar = m.colorbar(location=cbar_loc, pad='7%') else: cbar = m.colorbar(location=cbar_loc, pad='7%', ticks=cbar_ticks) if cbar_loc == 'left': cbar.ax.xaxis.get_offset_text().set_position((10,0))
def run(FILE_NAME): DATAFIELD_NAME = 'dHat' if USE_NETCDF4: from netCDF4 import Dataset nc = Dataset(FILE_NAME) var = nc.variables[DATAFIELD_NAME] # This datafield has scale factor and add offset attributes, but no # fill value. We'll turn off automatic scaling and do it ourselves. var.set_auto_maskandscale(False) data = nc.variables[DATAFIELD_NAME][:].astype(np.float64) # Retrieve scale/offset attributes. scale_factor = var.scale_factor add_offset = var.add_offset # Retrieve the geolocation data. latitude = nc.variables['geolocation'][:,:,0] longitude = nc.variables['geolocation'][:,:,1] else: from pyhdf.SD import SD, SDC hdf = SD(FILE_NAME, SDC.READ) ds = hdf.select(DATAFIELD_NAME) data = ds[:,:].astype(np.double) # Handle scale/osffset attributes. attrs = ds.attributes(full=1) sfa=attrs["scale_factor"] scale_factor = sfa[0] aoa=attrs["add_offset"] add_offset = aoa[0] # Retrieve the geolocation data. geo = hdf.select('geolocation') latitude = geo[:,:,0] longitude = geo[:,:,1] data = data / scale_factor + add_offset # Draw an equidistant cylindrical projection using the high resolution # coastline database. m = Basemap(projection='cyl', resolution='h', llcrnrlat=30, urcrnrlat = 36, llcrnrlon=121, urcrnrlon = 133) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(30, 37), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(121, 133, 2), labels=[0, 0, 0, 1]) m.pcolormesh(longitude, latitude, data, latlon=True) cb = m.colorbar() cb.set_label('Unit:mm') basename = os.path.basename(FILE_NAME) plt.title('{0}\n{1}'.format(basename, DATAFIELD_NAME)) fig = plt.gcf() # plt.show() pngfile = "{0}.py.png".format(basename) fig.savefig(pngfile)
def plot_basins(self): basin_values = -np.ones((self.nx, self.ny)) for basin in self.basins: # @type basin Basin #if int(basin.name.split('_')[1]) not in [0,4,1,11,15,20,22,25]: continue for theCell in basin.cells: # @type theCell Cell i, j = theCell.coords() theValue = basin.id if theCell.next is not None else -2 basin_values[i,j] = theValue basin_values = np.ma.masked_where(basin_values == -1, basin_values) lons, lats = self.longitudes, self.latitudes lons = lons.copy() lons[lons <= 180] += 360 lon_min = np.min(lons) lon_max = np.max(lons) lat_min = np.min(lats) lat_max = np.max(lats) basemap = Basemap(llcrnrlon = lon_min, llcrnrlat = lat_min, urcrnrlon = lon_max, urcrnrlat = lat_max, resolution = 'i' ) lons, lats = basemap(lons, lats) colormap = plt.cm.get_cmap(name = 'prism', lut = len(self.basins)) colormap.set_under(color = 'k') basemap.pcolormesh(lons, lats, basin_values, cmap = colormap, vmin = 0) basemap.drawcoastlines() plt.show()
def raster_on_earth(lons, lats, data, vmin=None, vmax=None, loc='earth'): if loc == 'earth': m = Basemap(projection='cyl', resolution='c', llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180) elif loc in ['wa', 'west_atlantic']: m = Basemap(projection='cyl', resolution='c', llcrnrlat=0, urcrnrlat=60, llcrnrlon=-120, urcrnrlon=-30) elif loc in ['nwp', 'northwest_pacific']: m = Basemap(projection='cyl', resolution='c', llcrnrlat=0, urcrnrlat=50, llcrnrlon=100, urcrnrlon=180) if data is not None: plot_lons, plot_data = extend_data(lons, lats, data) lons, lats = np.meshgrid(plot_lons, lats) x, y = m(lons, lats) if vmin: m.pcolormesh(x, y, plot_data, vmin=vmin, vmax=vmax) else: m.pcolormesh(x, y, plot_data) m.drawcoastlines() p_labels = [0, 1, 0, 0] m.drawparallels(np.arange(-90., 90.1, 45.), labels=p_labels, fontsize=10) m.drawmeridians(np.arange(-180., 180., 60.), labels=[0, 0, 0, 1], fontsize=10)
def plot_field_2d(lons_2d, lats_2d, field_2d, start_lon = -180, end_lon = 0, color_map = None, minmax = (None, None) ): plt.figure() m = Basemap(llcrnrlon = start_lon,llcrnrlat = np.min(lats_2d), urcrnrlon = end_lon,urcrnrlat = np.max(lats_2d), resolution = 'l') m.drawmeridians(range(start_lon,end_lon,10)) m.drawparallels(range(-90,90,10)) # y, x = meshgrid(lats_2d, lons_2d) # lons_2d[lons_2d < start_lon] = lons_2d[lons_2d < start_lon] + 360 x, y = m(lons_2d, lats_2d) x -= 360 ###########CONVERTING LONGITUDE TO -180:180 field_2d = maskoceans(x, y, field_2d) m.pcolormesh(x, y, field_2d, cmap = color_map, vmin = minmax[0], vmax = minmax[1]) m.drawcoastlines() #plt.imshow(np.transpose(data[:,:]), origin = 'lower') #for plotting in order to see i,j we supply j,i numticks = color_map.N + 1 if color_map != None else 10 plt.colorbar(ticks = LinearLocator(numticks = numticks), format = '%.01f', orientation = 'vertical', shrink = 0.6)
def plot_global(cfsr_file): data = Dataset(cfsr_file,'r') lats=data.variables['lat'][:] lons=data.variables['lon'][:] array = np.squeeze(data.variables['irwin_cdr'][:,:,:]) latn=data.geospatial_lat_min latx=data.geospatial_lat_max lonn=data.geospatial_lon_min lonx=data.geospatial_lon_max data.close() lons2d, lats2d=np.meshgrid(lons,lats) m=Basemap(projection='merc', llcrnrlat=latn, urcrnrlat=latx, llcrnrlon=lonn, urcrnrlon=lonx, resolution='l') m.drawcoastlines() m.pcolormesh(lons2d, lats2d, array, latlon=True, cmap='gray') plt.show()
def snr(cflx, pco2): #~ plt.figure(figsize=(10, 10)) curr_map = Basemap(projection='cyl', llcrnrlon=ll_lon, llcrnrlat=ll_lat, urcrnrlon=ur_lon, urcrnrlat=ur_lat, resolution='i', area_thresh=100.) x, y = curr_map(lon, lat) vmin=0 vmax=10 V = np.arange(0, 10) plt.subplot(211) im = curr_map.pcolormesh(x, y, snr_func(cflx) , vmin=vmin, vmax=vmax, cmap=cmap) plt.axis('tight') plt.colorbar() curr_map.drawcoastlines() curr_map.fillcontinents(color='grey',lake_color='aqua') #~ plt.title('Cflux SNR') plt.subplot(212) im = curr_map.pcolormesh(x, y, snr_func(pco2), vmin=vmin, vmax=vmax, cmap=cmap) plt.axis('tight') plt.colorbar() curr_map.drawcoastlines() curr_map.fillcontinents(color='grey',lake_color='aqua') #~ plt.title('Dpco2 SNR') plt.savefig(FIGDIR + 'snrs.png') plt.close('all')
def plot(array,typep=None,clevel=None): fig,ax = plt.subplots() lats=array['lats'] lons=array['lons'] latm,lonm = np.meshgrid(lats,lons) latn = np.min(lats) latx = np.max(lats) lonn = np.min(lons) lonx = np.max(lons) m = Basemap(projection='merc', llcrnrlat=latn, urcrnrlat=latx, llcrnrlon=lonn, urcrnrlon=lonx, resolution='l', ax=ax) if typep == 'pcolor': m.pcolormesh(lonm.T,latm.T,array['data'],latlon=True) elif typep == 'contourf': X,Y=m(lonm.T, latm.T) m.contourf(X,Y,array['data'],clevel) m.drawparallels(lats[1::10],labels=[1,0,0,0]) m.drawmeridians(lons[1::20],labels=[0,0,0,1]) m.drawcoastlines() plt.show(block=False)
def plot_result(field = None): if field is None: return basemap = Basemap(projection = 'npstere', #area_thresh = 10000, lat_ts = 60, lat_0 = 60, lon_0 = -115, boundinglat=10 ) x = polar_stereographic.lons y = polar_stereographic.lats x, y = basemap(x, y) d = max(np.absolute(field.max()), np.absolute(field.min())) basemap.pcolormesh(x, y, field, cmap = mpl.cm.get_cmap('jet', 10), vmax = d, vmin = -d) plt.xlim(x.min(), x.max()) plt.ylim(y.min(), y.max()) plt.colorbar(ticks = LinearLocator(numticks = 11), format = "%.1f") basemap.drawcoastlines() #basemap.drawrivers() plt.savefig("gt_aex_minus_aey.png") pass
def _raster_on_earth(lons, lats, data, vmin=None, vmax=None, loc=None, colorbar=True, labels=True): if not loc: m = Basemap(projection='cyl', resolution='c', llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180) else: m = Basemap(projection='cyl', resolution='c', **loc) if data is not None: plot_lons, plot_data = _extend_data(lons, lats, data) lons, lats = np.meshgrid(plot_lons, lats) x, y = m(lons, lats) if vmin: m.pcolormesh(x, y, plot_data, vmin=vmin, vmax=vmax) else: m.pcolormesh(x, y, plot_data) m.drawcoastlines() if labels: p_labels = [0, 1, 0, 0] m.drawparallels(np.arange(-90., 90.1, 45.), labels=p_labels, fontsize=10) m.drawmeridians(np.arange(-180., 180., 60.), labels=[0, 0, 0, 1], fontsize=10) if colorbar and data is not None: m.colorbar(location='right', pad='7%') return m
def plot_cell_feature (data, cell_id_column, cell_lat_column, cell_long_column, richness_column, title=None, second_feature_data=None, second_feature_column=None): lats = np.asarray(np.unique(data[cell_lat_column])) lons = np.asarray(np.unique(data[cell_long_column])) lons, lats = np.meshgrid(lons,lats) richness = np.array(data[richness_column]) richness.shape = (len(np.unique(lats)), len(np.unique(lons))) richness_mask = ma.masked_where(np.isnan(richness),richness) if second_feature_column: second_feature = np.array(second_feature_data[second_feature_column]) second_feature.shape = (len(np.unique(lats)), len(np.unique(lons))) second_feature_data_mask = ma.masked_where(np.isnan(second_feature),second_feature) fig = plt.figure() m = Basemap(projection='merc',llcrnrlat=23.5,urcrnrlat=57, llcrnrlon=-140,urcrnrlon=-50,lat_ts=20,resolution='l') m.drawcoastlines(linewidth = 1.25) if np.nanmin(richness) < 20: vmin=0 else: vmin=round(np.nanmin(richness)-20, -1) im1 = m.pcolormesh(lons,lats,richness_mask,shading='flat',cmap=plt.cm.Blues,latlon=True, vmin=vmin) if second_feature_column: im2 = m.pcolormesh(lons,lats,second_feature_data_mask,shading='flat',cmap=plt.cm.RdYlBu,latlon=True) cb = m.colorbar(im1,"bottom", size="5%", pad="2%") plt.title(title)
def plot(self,key='Re'): """ Create a plot of a variable over the ORACLES study area. Parameters ---------- key : string See names for available datasets to plot. clf : boolean If True, clear off pre-existing figure. If False, plot over pre-existing figure. Modification history -------------------- Written: Michael Diamond, 08/16/2016, Seattle, WA Modified: Michael Diamond, 08/21/2016, Seattle, WA -Added ORACLES routine flight plan, Walvis Bay (orange), and Ascension Island Modified: Michael Diamond, 09/02/2016, Swakopmund, Namibia -Updated flihgt track """ plt.clf() size = 16 font = 'Arial' m = Basemap(llcrnrlon=self.lon.min(),llcrnrlat=self.lat.min(),urcrnrlon=self.lon.max(),\ urcrnrlat=self.lat.max(),projection='merc',resolution='i') m.drawparallels(np.arange(-180,180,5),labels=[1,0,0,0],fontsize=size,fontname=font) m.drawmeridians(np.arange(0,360,5),labels=[1,1,0,1],fontsize=size,fontname=font) m.drawmapboundary(linewidth=1.5) m.drawcoastlines() m.drawcountries() if key == 'Pbot' or key == 'Ptop' or key == 'Nd' or key == 'DZ': m.drawmapboundary(fill_color='steelblue') m.fillcontinents(color='floralwhite',lake_color='steelblue',zorder=0) else: m.fillcontinents('k',zorder=0) if key == 'Nd': m.pcolormesh(self.lon,self.lat,self.ds['%s' % key],cmap=self.colors['%s' % key],\ latlon=True,norm = LogNorm(vmin=self.v['%s' % key][0],vmax=self.v['%s' % key][1])) elif key == 'Zbf' or key == 'Ztf': levels = [0,250,500,750,1000,1250,1500,1750,2000,2500,3000,3500,4000,5000,6000,7000,8000,9000,10000] m.contourf(self.lon,self.lat,self.ds['%s' % key],levels=levels,\ cmap=self.colors['%s' % key],latlon=True,extend='max') elif key == 'DZ': levels = [0,500,1000,1500,2000,2500,3000,3500,4000,4500,5000,5500,6000,6500,7000] m.contourf(self.lon,self.lat,self.ds['%s' % key],levels=levels,\ cmap=self.colors['%s' % key],latlon=True,extend='max') else: m.pcolormesh(self.lon,self.lat,self.ds['%s' % key],cmap=self.colors['%s' % key],\ latlon=True,vmin=self.v['%s' % key][0],vmax=self.v['%s' % key][1]) cbar = m.colorbar() cbar.ax.tick_params(labelsize=size-2) cbar.set_label('[%s]' % self.units['%s' % key],fontsize=size,fontname=font) if key == 'Pbot' or key == 'Ptop': cbar.ax.invert_yaxis() m.scatter(14.5247,-22.9390,s=250,c='orange',marker='D',latlon=True) m.scatter(-14.3559,-7.9467,s=375,c='c',marker='*',latlon=True) m.scatter(-5.7089,-15.9650,s=375,c='chartreuse',marker='*',latlon=True) m.plot([14.5247,13,0],[-22.9390,-23,-10],c='w',linewidth=5,linestyle='dashed',latlon=True) m.plot([14.5247,13,0],[-22.9390,-23,-10],c='k',linewidth=3,linestyle='dashed',latlon=True) plt.title('%s from MSG SEVIRI on %s/%s/%s at %s UTC' % \ (self.names['%s' % key],self.month,self.day,self.year,self.time),fontsize=size+4,fontname=font) plt.show()
def doPlot2(lon,lat,aeroOptDep,title,figName,beginLatFig=-60,endLatFig=20,beginLonFig=-96,endLonFig=-13,\ beginLatReg=0,endLatReg=0,beginLonReg=0,endLonReg=0): m=Basemap(projection='cyl',resolution='l',llcrnrlat=beginLatFig,\ urcrnrlat=endLatFig,llcrnrlon=beginLonFig,urcrnrlon=endLonFig) #lon,lat=m(lon,lat) print figName parallels = np.arange(beginLatFig,endLatFig,(endLatFig-beginLatFig)/8.) m.drawparallels(parallels,labels=[1,0,0,1]) meridians = np.arange(beginLonFig,endLonFig,(endLonFig-beginLonFig)/4.) m.drawmeridians(meridians,labels=[1,0,0,1]) m.drawcountries(linewidth=0.5) m.drawcoastlines(linewidth=0.5) m.pcolormesh(lon,lat,aeroOptDep,vmin=0.,vmax=1) if beginLatReg==0 and endLatReg==0 and beginLonReg==0 and\ endLonReg==0: pass else: drawScreen(beginLatReg,endLatReg,beginLonReg,endLonReg,m) #print beginLatReg,endLatReg,beginLonReg,endLonReg cb=m.colorbar() plt.title(title) plt.savefig(figName+'.png',format='png',dpi=150) plt.clf()
def run(FILE_NAME): with h5py.File(FILE_NAME, mode='r') as f: name = '/Grid/IRprecipitation' data = f[name][:] units = f[name].attrs['units'] _FillValue = f[name].attrs['_FillValue'] data[data == _FillValue] = np.nan data = np.ma.masked_where(np.isnan(data), data) # Get the geolocation data latitude = f['/Grid/lat'][:] longitude = f['/Grid/lon'][:] m = Basemap(projection='cyl', resolution='l', llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(-90, 91, 45)) m.drawmeridians(np.arange(-180, 180, 45), labels=[True,False,False,True]) m.pcolormesh(longitude, latitude, data.T, latlon=True) cb = m.colorbar() cb.set_label(units) basename = os.path.basename(FILE_NAME) plt.title('{0}\n{1}'.format(basename, name)) fig = plt.gcf() # plt.show() pngfile = "{0}.py.png".format(basename) fig.savefig(pngfile)
def basemap_raster_mercator(lon, lat, grid, cmap = None): """ Render a raster in mercator projection. Locations with no values are rendered transparent. """ # longitude/latitude extent lons = (np.amin(lon), np.amax(lon)) lats = (np.amin(lat), np.amax(lat)) if cmap is None: cmap = mpl.cm.jet cmap.set_bad('w', 1.0) # construct spherical mercator projection for region of interest m = Basemap(projection='merc',llcrnrlat=lats[0], urcrnrlat=lats[1], llcrnrlon=lons[0],urcrnrlon=lons[1]) vmin,vmax = np.nanmin(grid),np.nanmax(grid) masked_grid = np.ma.array(grid,mask=np.isnan(grid)) fig = plt.figure(frameon=False) plt.axis('off') m.pcolormesh(lon,lat,masked_grid,latlon=True,cmap=cmap,vmin=vmin,vmax=vmax) str_io = StringIO.StringIO() plt.savefig(str_io,bbox_inches='tight',format='png',pad_inches=0,transparent=True) bounds = [ (lons[0],lats[0]),(lons[1],lats[0]),(lons[1],lats[1]),(lons[0],lats[1]) ] return str_io.getvalue(), bounds
def plotgrid(lon,lat,width=3000000,height=3000000) : import matplotlib import matplotlib.pyplot from matplotlib.figure import Figure from matplotlib.backends.backend_agg import FigureCanvasAgg from mpl_toolkits.basemap import Basemap #print "testlon, testlat:",lon[1,1],lat[1,1] #figure = Figure() #ax = figure.add_subplot(111) #canvas = FigureCanvasAgg(figure) figure = matplotlib.pyplot.figure(figsize=(8,8)) ax=figure.add_subplot(111) #Pick center longitude ix,iy=[elem/2 for elem in lon.shape] clon=lon[ix,iy] clat=lat[ix,iy] # Probably a way of estimating the width here... #print width,height #print clon,clat m = Basemap(projection='stere',lon_0=clon,lat_0=clat,resolution='l',width=width,height=height,ax=ax) x,y = m(lon,lat) # Pick a suitable set of grid lines nlines=10 stepx,stepy=[elem/nlines for elem in lon.shape] x2=numpy.zeros((nlines+1,nlines+1)) y2=numpy.zeros((nlines+1,nlines+1)) #print x2.shape,x[::stepx,::stepy].shape x2[:-1,:-1]=x[::stepx,::stepy] x2[-1,:-1]=x[-1,::stepy] x2[:-1,-1]=x[::stepx,-1] x2[-1,-1]=x[-1,-1] y2[:-1,:-1]=y[::stepx,::stepy] y2[:-1,-1]=y[::stepx,-1] y2[-1,:-1]=y[-1,::stepy] y2[-1,-1]=y[-1,-1] m.drawcoastlines() m.drawmapboundary() # draw a line around the map region m.drawparallels(numpy.arange(-90.,120.,30.),labels=[1,0,0,0]) # draw parallels m.drawmeridians(numpy.arange(0.,420.,60.),labels=[0,0,0,1]) # draw meridians v=numpy.zeros(x.shape) col=".8" cmap=matplotlib.colors.ListedColormap([col,col]) #m.pcolormesh(x,y,v,ax=ax,edgecolor="k",cmap=cmap) m.pcolormesh(x,y,v,ax=ax,edgecolor="none",cmap=cmap) for j in range(y2.shape[1]) : m.plot(x2[:,j],y2[:,j],color="b",lw=2) for i in range(y2.shape[0]) : m.plot(x2[i,:],y2[i,:],color="r",lw=2) ax.set_title("Every %d in x(blue) and every %d in y(red) shown"%(stepy,stepx)) return figure
def run(FILE_NAME): if USE_NETCDF4: from netCDF4 import Dataset nc = Dataset(FILE_NAME) grp = nc.groups['HDFEOS'].groups['GRIDS'].groups['SET1'] data_var = grp.groups['Data Fields'].variables['E'] data = data_var[:] data_longname = data_var.long_name data_units = data_var.units else: import h5py with h5py.File(FILE_NAME, mode='r') as f: dset_var = f['/HDFEOS/GRIDS/SET1/Data Fields/E'] data = dset_var[:] # String attributes actually come in as the bytes type and should # be decoded to UTF-8 (python3). data_units = dset_var.attrs['units'].decode() data_longname = dset_var.attrs['long_name'].decode() fv = dset_var.attrs['_FillValue'][0] # We have to apply the fill value ourselves. data[data == fv] = np.nan data = np.ma.masked_array(data, np.isnan(data)) # The projection is GEO, so we can construct the lat/lon arrays ourselves. scaleX = 360.0 / data.shape[1] scaleY = 180.0 / data.shape[0] longitude = np.arange(data.shape[1]) * scaleX - 180 + scaleX/2 latitude = np.arange(data.shape[0]) * scaleY - 90 + scaleY/2 # Draw an equidistant cylindrical projection using the low resolution # coastline database. m = Basemap(projection='cyl', resolution='l', llcrnrlat=-90, urcrnrlat = 90, llcrnrlon=-180, urcrnrlon = 180) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(-90., 120., 30.), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(-180, 180., 45.), labels=[0, 0, 0, 1]) m.pcolormesh(longitude, latitude, data, latlon=True) cb = m.colorbar() cb.set_label(data_units) basename = os.path.basename(FILE_NAME) plt.title('{0}\n{1}'.format(basename, data_longname)) fig = plt.gcf() # plt.show() pngfile = "{0}.py.png".format(basename) fig.savefig(pngfile)
def run(FILE_NAME): # Identify the data field. DATAFIELD_NAME = 'Longwave Flux (2.5R)' if USE_NETCDF4: from netCDF4 import Dataset nc = Dataset(FILE_NAME) data = nc.variables[DATAFIELD_NAME][:].astype(np.float64) else: from pyhdf.SD import SD, SDC hdf = SD(FILE_NAME, SDC.READ) # Read dataset. data2D = hdf.select(DATAFIELD_NAME) data = data2D[:,:] # Set fillvalue and units. # See "CERES Data Management System ES-4 Collection Guide" [1] and a sample # image by NASA [2] for details. The fillvalue is 3.4028235E38. Here, we # just use the max of the data. fillvalue = np.max(data) data[data == fillvalue] = np.nan datam = np.ma.masked_array(data, mask=np.isnan(data)) # Set fillvalue and units. # See "CERES Data Management System ES-4 Collection Guide" [1] and a # sample image by NASA [2] for details. # The fillvalue is 3.4028235E38. Here, we use max value from the dataset. units = 'Watts/Meter^2' ysize, xsize = data.shape xinc = 360.0 / xsize yinc = 180.0 / ysize x0, x1 = (-180, 180) y0, y1 = (-90, 90) longitude = np.linspace(x0 + xinc/2, x1 - xinc/2, xsize) latitude = np.linspace(y0 + yinc/2, y1 - yinc/2, ysize) # Flip the latitude to run from 90 to -90 latitude = latitude[::-1] # The data is global, so render in a global projection. m = Basemap(projection='cyl', resolution='l', llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(-90.,90,45)) m.drawmeridians(np.arange(-180.,180,45), labels=[True,False,False,True]) m.pcolormesh(longitude, latitude, datam, latlon=True) cb = m.colorbar() cb.set_label(units) basename = os.path.basename(FILE_NAME) plt.title('{0}\n{1}'.format(basename, DATAFIELD_NAME)) fig = plt.gcf() # plt.show() pngfile = "{0}.py.png".format(basename) fig.savefig(pngfile)
def draw_map(file, map=None, show=True, title=None, log=False, map_type=None): '''Use Matplotlib's basemap to generate a map of a given BIOCLIM data file. You can supply a Basemap object (in any projection) as the optional keyword argument "map." If none is provided, the default Miller projection will be used.''' data, no_value, ul, dims, size = extract_attributes(file) data = get_dataset(file) lats = np.linspace(ul[0], ul[0]-dims[0]*size[0], size[0], endpoint=False) lons = np.linspace(ul[1], ul[1]+dims[1]*size[1], size[1], endpoint=False) if map_type == 'variance': x, y = np.meshgrid(lons, lats) raster = np.zeros(x.shape) values = get_spatial_variance(file, [(lat, lon) for lat in lats for lon in lons]) for a in range(data.shape[0]): for b in range(data.shape[1]): data[a,b] = values.pop() else: raster = data.ReadAsArray() # because missing data is entered as -9999, created a masked array so that # these points will not be plotted values = np.ma.masked_where(raster==no_value, raster) # log transform data, if requested if log: if (values < 0).any(): values -= min(values) values = np.log1p(values) plt.figure() if title is None: title = '%s' % file if file in variable_names: title += ': %s' % variable_names[file] plt.title(title) if map is None: map = Basemap(projection='mill',lon_0=0) map.drawcoastlines(linewidth=1) map.drawcountries(linewidth=1) map.drawstates(linewidth=0.5) parallels = np.arange(-90.,90,10.) map.drawparallels(parallels,labels=[False,True,True,False]) meridians = np.arange(-180.,180.,20.) map.drawmeridians(meridians,labels=[True,False,False,True]) x, y = np.meshgrid(lons, lats) map.pcolormesh(x, y, data=values, latlon=True, cmap=plt.cm.Spectral_r) cbar = plt.colorbar() if show: plt.show()
def run(FILE_NAME): DATAFIELD_NAME = 'Temperature_MW_A' if USE_NETCDF4: from netCDF4 import Dataset nc = Dataset(FILE_NAME) # The variable has a fill value, # so netCDF4 converts it to a float64 masked array for us. data = nc.variables[DATAFIELD_NAME][11,:,:] latitude = nc.variables['Latitude'][:] longitude = nc.variables['Longitude'][:] else: from pyhdf.SD import SD, SDC hdf = SD(FILE_NAME, SDC.READ) # List available SDS datasets. # print hdf.datasets() # Read dataset. data3D = hdf.select(DATAFIELD_NAME) data = data3D[11,:,:] # Read geolocation dataset. lat = hdf.select('Latitude') latitude = lat[:,:] lon = hdf.select('Longitude') longitude = lon[:,:] # Handle fill value. attrs = data3D.attributes(full=1) fillvalue=attrs["_FillValue"] # fillvalue[0] is the attribute value. fv = fillvalue[0] data[data == fv] = np.nan data = np.ma.masked_array(data, np.isnan(data)) # Draw an equidistant cylindrical projection using the low resolution # coastline database. m = Basemap(projection='cyl', resolution='l', llcrnrlat=-90, urcrnrlat = 90, llcrnrlon=-180, urcrnrlon = 180) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(-90., 120., 30.), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(-180., 181., 45.), labels=[0, 0, 0, 1]) m.pcolormesh(longitude, latitude, data, latlon=True, alpha=0.90) cb = m.colorbar() cb.set_label('Unit:K') basename = os.path.basename(FILE_NAME) plt.title('{0}\n {1} at TempPrsLvls=11'.format(basename, DATAFIELD_NAME)) fig = plt.gcf() # plt.show() pngfile = "{0}.{1}.py.png".format(basename, DATAFIELD_NAME) fig.savefig(pngfile)
def plot_sa_diff_figure(control_dataset, data, sa_mask): f = plt.figure('sa_diff') plt.set_cmap('RdGy_r') graph_settings = ( ((-4, 4), np.arange(-4, 4.1, 2)), ((-6, 6), np.arange(-6, 6.1, 3)), ((-0.7, 0.7), np.arange(-0.6, 0.61, 0.3)), ((-4, 4), np.arange(-4, 4.1, 2)), ((-0.2, 0.2), np.arange(-0.2, 0.21, 0.1))) variables = ['precip', 'surf_temp', 'q', 'field1389', 'field1385'] nice_names = {'precip': '$\Delta$Precip (mm/day)', 'surf_temp': '$\Delta$Surf temp (K)', 'q':'$\Delta$Humidity (g/kg)', 'field1389': '$\Delta$NPP (g/m$^2$/day)', 'field1385': '$\Delta$Soil moisture'} f.subplots_adjust(hspace=0.2, wspace=0.1) for i in range(len(variables)): variable = variables[i] ax = plt.subplot(2, 3, i + 1) ax.set_title(nice_names[variable]) variable_diff = data['data']['1pct'][variable] - data['data']['ctrl'][variable] if variable == 'field1389': variable_diff *= 24*60*60*1000 # per s to per day, kg to g. lons, lats = get_vars_from_control_dataset(control_dataset) vmin, vmax = graph_settings[i][0] #general_plot(control_dataset, variable_diff.mean(axis=0), vmin=graph_settings[i][0][0], vmax=graph_settings[i][0][1], loc='sa', sa_mask=sa_mask) plot_data = variable_diff.mean(axis=0) #plot_south_america(lons, lats, sa_mask, plot_data, vmin, vmax) if variable in ('surf_temp', 'precip', 'q'): # unmasked. data_masked = plot_data plot_lons, plot_data = extend_data(lons, lats, data_masked) else: data_masked = np.ma.array(plot_data, mask=sa_mask) plot_lons, plot_data = extend_data(lons, lats, data_masked) lons, lats = np.meshgrid(plot_lons, lats) m = Basemap(projection='cyl', resolution='c', llcrnrlat=-60, urcrnrlat=15, llcrnrlon=-85, urcrnrlon=-32) x, y = m(lons, lats) m.pcolormesh(x, y, plot_data, vmin=vmin, vmax=vmax) m.drawcoastlines() if i == 0 or i == 3: m.drawparallels(np.arange(-60.,15.,10.), labels=[1, 0, 0, 0], fontsize=10) elif i == 2 or i == 4: m.drawparallels(np.arange(-60.,15.,10.), labels=[0, 1, 0, 0], fontsize=10) else: m.drawparallels(np.arange(-60.,15.,10.)) m.drawmeridians(np.arange(-90.,-30.,10.), labels=[0, 0, 0, 1], fontsize=10) cbar = m.colorbar(location='bottom', pad='7%', ticks=graph_settings[i][1])
def run(FILE_NAME): DATAFIELD_NAME = 'SurfaceTemperature' # The dataset is (6144 x 6400). Subset it to be around than 1K x 1K # Otherwise, the plot will skip processing some regions. rows = slice(0, 6144, 6) cols = slice(0, 6400, 6) if USE_NETCDF4: from netCDF4 import Dataset nc = Dataset(FILE_NAME) data = nc.variables[DATAFIELD_NAME][rows, cols] # Retrieve the geolocation data. latitude = nc.variables['Latitude'][rows, cols] longitude = nc.variables['Longitude'][rows, cols] else: from pyhdf.SD import SD, SDC hdf = SD(FILE_NAME, SDC.READ) # Read dataset. data2D = hdf.select(DATAFIELD_NAME) data = data2D[rows,cols] # Read geolocation dataset. lat = hdf.select('Latitude') latitude = lat[rows,cols] lon = hdf.select('Longitude') longitude = lon[rows,cols] # Apply the fill value. The valid minimum is zero, although there's no # attribute. data[data < 0] = np.nan data = np.ma.masked_array(data, np.isnan(data)) # Render the data in a lambert azimuthal equal area projection. m = Basemap(projection='nplaea', resolution='l', boundinglat=60, lon_0=43) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(50, 90, 10), labels=[1, 0, 0, 1]) m.drawmeridians(np.arange(-180, 180, 30)) x, y = m(longitude, latitude) m.pcolormesh(x, y, data) cb = m.colorbar() cb.set_label('Unknown') basename = os.path.basename(FILE_NAME) plt.title('{0}\n{1}'.format(basename, DATAFIELD_NAME)) fig = plt.gcf() # plt.show() pngfile = "{0}.py.png".format(basename) fig.savefig(pngfile)
def plotmap(variable, mode='multi', tstep=0, proj='merc', style='pcolormesh', clevs=20): latitudes = variable.coords['latitude'][:] longitudes = variable.coords['longitude'][:] lats, lons = makegrid(latitudes, longitudes, variable.shape[-2:]) vmin, vmax = variable[:].min(), variable[:].max() llcrnrlat, urcrnrlat = lats.min(), lats.max() llcrnrlon, urcrnrlon = lons.min(), lons.max() lat_ts = lats.mean() lon_0 = lons.mean() fig = plt.figure(figsize=(10,14)) cols, rows = 1, 1 if mode == 'tstep': data = variable[:][tstep] elif mode == 'mean': data = variable[:].mean(axis=0) elif mode == 'multi': nplots = variable.shape[0] cols = int(np.floor(np.sqrt(nplots))) rows = int(np.ceil(np.sqrt(nplots))) print nplots, cols, rows fig, axes = plt.subplots(rows, cols, squeeze=False) for col in range(cols): for row in range(rows): print col, row, col+cols*row if proj == 'merc': m = Basemap(projection='merc',llcrnrlat=llcrnrlat,urcrnrlat=urcrnrlat,llcrnrlon=llcrnrlon,urcrnrlon=urcrnrlon,lat_ts=lat_ts,resolution='l', ax=axes[row][col]) elif proj == 'lcc': m = Basemap(projection='lcc',llcrnrlat=llcrnrlat,urcrnrlat=urcrnrlat,llcrnrlon=llcrnrlon,urcrnrlon=urcrnrlon,lat_0=lat_ts,lon_0=lon_0,resolution='l', ax=axes[row][col]) x, y = m(lons, lats) if mode == 'multi': data = variable[col+cols*row] if style == 'pcolormesh': m.pcolormesh(x, y, data, vmin=vmin, vmax=vmax, cmap='Blues') elif style == 'contour': m.contourf(x, y, data, clevs) m.contour(x, y, data, clevs, colors='black') m.fillcontinents(color='white',lake_color='aqua',zorder=0) m.drawcoastlines(linewidth=1.0) plt.tight_layout() return plt
def run(FILE_NAME): # Identify the data field. DATAFIELD_NAME = 'AlbedoLocal' hdf = SD(FILE_NAME, SDC.READ) # Read dataset. data4D = hdf.select(DATAFIELD_NAME) # Convert 4-D data to 2-D data by subsetting. SOMBlockDim = 50; NBandDim = 0; data = data4D[SOMBlockDim,:,:,NBandDim].astype(np.double) # Read geolocation dataset from HDF-EOS2 dumper output. GEO_FILE_NAME = 'lat_MISR_TC_ALBEDO_P223_F05_lvl50.output' GEO_FILE_NAME = os.path.join(os.environ['HDFEOS_ZOO_DIR'], GEO_FILE_NAME) lat = np.genfromtxt(GEO_FILE_NAME, delimiter=',', usecols=[0]) lat = lat.reshape(data.shape) GEO_FILE_NAME = 'lon_MISR_TC_ALBEDO_P223_F05_lvl50.output' GEO_FILE_NAME = os.path.join(os.environ['HDFEOS_ZOO_DIR'], GEO_FILE_NAME) lon = np.genfromtxt(GEO_FILE_NAME, delimiter=',', usecols=[0]) lon = lon.reshape(data.shape) # Read attributes. attrs = data4D.attributes(full=1) fva=attrs["_FillValue"] _FillValue = fva[0] # Apply the fill value. data[data == _FillValue] = np.nan datam = np.ma.masked_array(data, mask=np.isnan(data)) # Set the limit for the plot. m = Basemap(projection='cyl', resolution='h', llcrnrlat=np.min(lat), urcrnrlat = np.max(lat), llcrnrlon=np.min(lon), urcrnrlon = np.max(lon)) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(np.floor(np.min(lat)), np.ceil(np.max(lat)), 1), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(np.floor(np.min(lon)), np.ceil(np.max(lon)), 1), labels=[0, 0, 0, 1]) m.pcolormesh(lon, lat, datam, latlon=True) cb = m.colorbar() cb.set_label('No Unit') basename = os.path.basename(FILE_NAME) plt.title('{0}\n{1} at SOMBlockDim=50 NBandDim=0'.format(basename, DATAFIELD_NAME)) fig = plt.gcf() # plt.show() pngfile = "{0}.l50.py.png".format(basename) fig.savefig(pngfile)
def mapData(self, data, label=None,lon0=-179,lat0=-80,lon1=179,lat1=80): from mpl_toolkits.basemap import Basemap lons,lats=np.meshgrid(self.lonbounds, self.latbounds) m=Basemap(lon0,lat0,lon1,lat1) m.pcolormesh(np.transpose(lons),np.transpose(lats),np.transpose(data), latlon=True) m.drawcoastlines() cb= m.colorbar() if label is not None: cb.set_label(label) return m,cb
sst = nc.variables['sst4'][:] lon = nc.variables['lon'][:] lat = nc.variables['lat'][:] timesst = nc.time_coverage_start # Interpolate the sst field onto the mooring position llon, llat = np.meshgrid(lon, lat) f = interpolate.interp2d(lon, lat, sst, kind='linear') sst_interp = f(lonmooring, latmooring) lon, lat = m(llon, llat) fig = plt.figure() ax = fig.add_subplot(111) m.pcolormesh(lon, lat, sst, cmap=cmap, norm=norm) if sst_interp<35: plt.text(lonmooring2, latmooring2, ' ' + str(np.round(sst_interp[0], 2)), ha='left', va='center') scat = m.scatter(lonmooring2, latmooring2, s=45, c=sst_interp, cmap=cmap, norm=norm) m.drawcoastlines(ax=ax, linewidth=0.2) m.fillcontinents(color = 'gray') m.drawparallels(np.arange(round(coordinates[2]), coordinates[3], dlat), linewidth=0., labels=[1, 0, 0, 0], fontname='Times New Roman', fontsize=16, zorder=1) m.drawmeridians(np.arange(round(coordinates[0]), coordinates[1], dlon), linewidth=0., labels=[0, 0, 0, 1], fontname='Times New Roman', fontsize=16, zorder=1) cbar = plt.colorbar(scat, extend='both', shrink=0.7) cbar.set_label('$^{\circ}$C', rotation=0, horizontalalignment='left') cbar.set_ticks(bounds) plt.title(timesst[:10]) # plt.savefig(figdir+ff)
def plot_fields(fields, break_value=None): """ Plot *fields*. Each element in *fields* should be a `Field` instance. Plots on orthogonal projection, with lon_0, lat_0 taken from mean of lon, lat of first element in *fields*. """ from mpl_toolkits.basemap import Basemap from matplotlib import pyplot as plt from utility_functions import broken_cmap_r # Comment: utility_functions is a separate package, created by J.Malm, # but which we can not find. If we want to run this part of the code, it # might be changed to something from matplotlib instead. # broken_cmap_r is supposed to create a colormap with a gradient on one side # of a threshold, and another gradient on the other side, and a unique # colour on the theshold it self. # Sara Hornquist 2015-03-12 lon_0 = fields[0].lon.mean() lat_0 = fields[0].lat.mean() vmin, vmax, break_value = limits([f.data for f in fields], break_value) cmap = broken_cmap_r(vmin=vmin, vmax=vmax, break_value=break_value) fig = plt.figure() ax = None for ix, f in enumerate(fields): ax = fig.add_subplot(len(fields) % 2 + 1, len(fields) // 2 + 1, ix + 1, sharex=ax, sharey=ax) m = Basemap(projection='ortho', lon_0=lon_0, lat_0=lat_0, lat_ts=0, resolution='c', ax=ax) m.drawcoastlines(linewidth=.5, color='g') step = (f.data.shape[1] // 256) or 1 # don't use full gigantic arrays _slice = (slice(None, None, step), ) * 2 x, y = m(f.lon[_slice], f.lat[_slice]) # Mask out pixels outside projection limb # on_map = (x < 1e20) | (y < 1e20) # data = np.ma.array(f.data[_slice], mask=~on_map) data = f.data[_slice] logger.debug("data.shape = %r" % (data.shape, )) # mesh = m.pcolor(x, y, data, vmin=vmin, vmax=vmax, cmap=cmap) # pcolormesh is much faster, but I can't get rid of off-projection drawing mesh = m.pcolormesh(x, y, data, vmin=vmin, vmax=vmax, cmap=cmap) fig.colorbar(mesh) ax.set_title(f.desc) m.drawmeridians(range(0, 360, 20), linewidth=.5) m.drawparallels(range(-80, 90, 10), linewidth=.5) # Mark 70 deg latitudes (cut off for validation) m.drawparallels([-70, 70], color='r', dashes=[1, 0], latmax=70) return fig
llcrnrlat=-65, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180, resolution='c') x, y = map(lon2, lat2) map.drawcoastlines() map.drawcountries() map.drawmapboundary() clmhis = ma.masked_where(clmhis <= 0., clmhis) clmhis1 = ma.masked_where(clmhis1 <= 0., clmhis1) cc = clmhis1 - clmhis cc = ma.masked_where(cc == 0., cc) cs = map.pcolormesh(x, y, cc, cmap=plt.cm.bwr, vmin=-1, vmax=1) cbar = map.colorbar(cs, location='bottom', size="4%", pad="2%") cbar.ax.tick_params(labelsize=12) plt.axis('off') ax2 = fig.add_subplot(222) ax2.set_title("ISAM yield difference 2010s (t/ha)", fontsize=18) map = Basemap(projection='cyl', llcrnrlat=-65, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180, resolution='c') map.drawcoastlines() map.drawcountries() map.drawmapboundary()
PRMSL = grb.values lat, lon = grb.latlons() date = str(grb['dataDate']) hour = str(grb['hour']) fcsthr = str(grb[u'forecastTime']) cycle = date.join(hour) m = Basemap(projection='lcc',lat_1=45., lat_2=55, lat_0=np.median(lat),lon_0=np.median(lon),\ rsphere=(6378137.00,6356752.3142),\ llcrnrlon=lon.min(),urcrnrlon=lon.max(), \ llcrnrlat=lat.min(),urcrnrlat=lat.max(), \ area_thresh=500.) m.drawcoastlines() #m.drawparallels(np.arrange(lat.min(),lat.max(),20)) #m.drawmeridians(np.arrange(lon.min(),lon.max(),60)) m.drawmapboundary() x, y = m(lon, lat) cs = m.pcolormesh(x, y, PRMSL, shading='flat', cmap=plt.cm.jet) plt.colorbar(cs, orientation='vertical') plt.title('MSLP for 04E %s hr fcst from %s cycle' % (fcsthr, cycle)) plt.show()
base_map = Basemap(llcrnrlon=116.362, urcrnrlon=121.9752, llcrnrlat=30.7578, urcrnrlat=35.1245, lon_0=119, lat_0=33, ax=ax) base_map.drawparallels(np.arange(30, 36, 1), labels=[1, 0, 0, 0], fontsize=12, ax=ax) base_map.drawmeridians(np.arange(116, 122, 1), labels=[0, 0, 0, 1], fontsize=12, ax=ax) base_map.readshapefile('shp/江苏省_行政边界', 'Js', True, default_encoding='ISO-8859-1') cp = base_map.pcolormesh(xgrid, ygrid, zgrid, cmap='Spectral_r', shading='auto') colorbar = base_map.colorbar(cp, label='IDW') base_map.contour(xgrid, ygrid, zgrid, colors='w') colorbar.outline.set_edgecolor('none') plt.axis('off') plt.show()
#!/usr/bin/python ''' Module: read_and_map_mod_aerosol.py ========================================================================================== Disclaimer: The code is for demonstration purposes only. Users are responsible to check for accuracy and revise to fit their objective. Author: Justin Roberts-Pierel, 2015 Organization: NASA ARSET Purpose: To extract AOD data from a MODIS HDF4 file (or series of files) and create a map of the resulting data See the README associated with this module for more information. ========================================================================================== ''' #import necessary modules from pyhdf import SD import numpy as np from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt import sys import glob #loops through all files listed in the text file for FILE_NAME in ['temperature/MYD11C1.A2020022.006.2020027211827.hdf']: FILE_NAME = FILE_NAME.strip() try: # open the hdf file for reading hdf = SD.SD(FILE_NAME) except: print('Unable to open file: \n' + FILE_NAME + '\n Skipping...') continue # Get lat and lon info latitude = np.arange(-90, 90.05, 0.05)[::-1] print(latitude)
plt.figure() grib = 'multi_1.at_10m.t00z.f000.grib2' grbs = pygrib.open(grib) # In this example we will extract the same significant wave height field we used in the # first example. Remember that indexing in Python starts at zero. grb = grbs.select(name='Significant height of wind waves')[0] data = grb.values lat, lon = grb.latlons() # From this point on the code is almost identical to the previous example. # Plot the field using Basemap. Start with setting the map projection using the limits of the lat/lon data itself: m=Basemap(projection='mill',lat_ts=10,llcrnrlon=lon.min(), \ urcrnrlon=lon.max(),llcrnrlat=lat.min(),urcrnrlat=lat.max(), \ resolution='c') # Convert the lat/lon values to x/y projections. x, y = m(lon, lat) # Next, plot the field using the fast pcolormesh routine and set the colormap to jet. cs = m.pcolormesh(x, y, data, shading='flat', cmap=plt.cm.jet) # Add a coastline and axis values. m.drawcoastlines() m.fillcontinents() m.drawmapboundary() m.drawparallels(np.arange(-90., 120., 30.), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(-180., 180., 60.), labels=[0, 0, 0, 1]) # Add a colorbar and title, and then show the plot. plt.colorbar(cs, orientation='vertical') plt.title('Example 2: NWW3 Significant Wave Height from GRiB') plt.show()
lat,lon = grb.latlons() # Set the names of the latitude and longitude variables in your input GRIB file print(len(lat)) print(len(lon)) # BIG # "area": "70/-15/30/30", # m=Basemap(projection='mill', llcrnrlon=-15,urcrnrlon=30,llcrnrlat=30,urcrnrlat=70,resolution='h') # 64x64 # "area": "58.8/8.1/40/27", # m=Basemap(projection='mill', llcrnrlon=8.1,urcrnrlon=27,llcrnrlat=40,urcrnrlat=58.8,resolution='h') # 32x32 # "area": "54.3/13/45/22", m=Basemap(projection='mill', llcrnrlon=13,urcrnrlon=22,llcrnrlat=45,urcrnrlat=54.3,resolution='h') x, y = m(lon,lat) # cs = m.pcolormesh(x,y,data-273.15,cmap=plt.cm.hot) cs = m.pcolormesh(x,y,data-273.15) my_coast = m.drawcoastlines() my_states = m.drawcountries() # my_p = m.drawparallels(np.arange(40,60,2),labels=[1,1,0,0]) # my_m = m.drawmeridians(np.arange(10,28,2),labels=[0,0,0,1]) plt.colorbar(pad=0.10, label='Teplota') plt.title('Teplota') # Set the name of the variable to plot plt.savefig('temp_32_title.png') # Set the output file name plt.show()
resolution='f', ax=axes[0]) m1.drawcoastlines(linewidth=0.3) m1.drawcountries() m1.drawmapscale(-121, 58.7, lons_d01.mean(), lats_d01.mean(), 100) m1.drawparallels(np.arange(-50, 70, 5), linewidth=0.5, labels=[True, False, False, False], fontsize=20) m1.drawmeridians(np.arange(-130, -100, 5), linewidth=0.5, labels=[False, False, False, False], fontsize=20) map1 = m1.pcolormesh(lons_d01, lats_d01, avg_daily_obs_d01, latlon=True, cmap=newcmp) axes[0].set_title('G4ICE - 9 km\n', fontsize=30) mstats = 'm = %.4f, s = %.4f' % (np.nanmean(avg_daily_obs_d01), np.nanstd(avg_daily_obs_d01)) plt.text(1.0, 1.0, mstats, horizontalalignment='right', verticalalignment='bottom', transform=axes[0].transAxes, fontsize=my_fontsize) map1.set_clim(0, 0.05) m1 = Basemap(projection='lcc',
def run(FILE_NAME): DATAFIELD_NAME = 'Water_Vapor' if USE_NETCDF4: from netCDF4 import Dataset nc = Dataset(FILE_NAME) # The netCDF4 module will correctly apply fill value and # scaling equation. data = nc.variables[DATAFIELD_NAME][:] latitude = nc.variables['Latitude'][:] longitude = nc.variables['Longitude'][:] # Retrieve attributes. units = nc.variables[DATAFIELD_NAME].units long_name = nc.variables[DATAFIELD_NAME].long_name else: from pyhdf.SD import SD, SDC hdf = SD(FILE_NAME, SDC.READ) # Read dataset. data2D = hdf.select(DATAFIELD_NAME) data = data2D[:, :].astype(np.double) # Read geolocation dataset. lat = hdf.select('Latitude') latitude = lat[:, :] lon = hdf.select('Longitude') longitude = lon[:, :] # Retrieve attributes. attrs = data2D.attributes(full=1) lna = attrs["long_name"] long_name = lna[0] aoa = attrs["add_offset"] add_offset = aoa[0] fva = attrs["_FillValue"] _FillValue = fva[0] sfa = attrs["scale_factor"] scale_factor = sfa[0] ua = attrs["units"] units = ua[0] vra = attrs["valid_range"] valid_min = vra[0][0] valid_max = vra[0][1] # Apply _FillValue, scale and offset. invalid = np.logical_or(data > valid_max, data < valid_min) invalid = np.logical_or(invalid, data == _FillValue) data[invalid] = np.nan data = data * scale_factor + add_offset data = np.ma.masked_array(data, np.isnan(data)) # The data is local to Alaska, so no need for a global or hemispherical # projection. m = Basemap(projection='laea', resolution='l', lat_ts=65, lat_0=65, lon_0=-150, width=4800000, height=3500000) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(40, 81, 10), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(-210, -89., 30), labels=[0, 0, 0, 1]) m.pcolormesh(longitude, latitude, data, latlon=True) cb = m.colorbar() cb.set_label(units) basename = os.path.basename(FILE_NAME) plt.title('{0}\n{1}'.format(basename, long_name)) fig = plt.gcf() # plt.show() pngfile = "{0}.py.png".format(basename) fig.savefig(pngfile)
def main(): ## Problem parameters # The intended flight #source = Point_l(14.7,100.6) #target = Point_l(-3.6,105.3) source = Point_l( -5.083052, 119.606448 ) # Our start target = Point_l( 13.610979, 100.753909 ) # Our end # The problem domain and resolution ''' lat_min = -10.0 lat_max = 20.0 lon_min = 90.0 lon_max = 120.0 lat_res = 150 lon_res = 150 ''' # Rectangle ''' lat_min = 20 lat_max = 40 lon_min = 140 lon_max = 160 lat_res = 200 lon_res = 200 ''' # Case study lat_min = -10 lat_max = 20 lon_min = 90 lon_max = 130 lat_res = 300 lon_res = 300 dim = Dimension_l(lat_min, lat_max, lat_res, lon_min, lon_max, lon_res) # create Basemap instance. m = Basemap(projection='mill',\ llcrnrlat=lat_min,urcrnrlat=lat_max,\ llcrnrlon=lon_min,urcrnrlon=lon_max,\ resolution='l') # Convert the problem domain to meters x_min, y_min = m(lon_min, lat_min) x_max, y_max = m(lon_max, lat_max) dim_m = Dimension_m(y_min, y_max, lat_res, x_min, x_max, lon_res) source_m = Point_m(m(source.lon,source.lat)[0], m(source.lon, source.lat)[1]) target_m = Point_m(m(target.lon,target.lat)[0], m(target.lon, target.lat)[1]) print("X resolution (km) is: " + str((dim_m.x_max - dim_m.x_min) / (dim_m.x_res - 1) / 1000.0 )) print("Y resolution (km) is: " + str((dim_m.y_max - dim_m.y_min) / (dim_m.y_res - 1) / 1000.0 )) # Airport locations airports = get_airports(dim) airports_m = [Point_m(m(apt.lon,apt.lat)[0], m(apt.lon, apt.lat)[1]) for apt in airports] # Get current data U_m, V_m = get_currents(dim_m, dim, m) # Get depth data depth_m = get_depths(dim, dim_m, m) ## Run calculations to evaluate the problem print("\n=== Evaluating problem\n") # Calculate costs costs_sp = calc_costs_sp(dim_m, airports_m) costs_sb = calc_costs_sb(dim_m) init_vals = calc_init_values(dim_m, source_m, target_m, airports_m, m) sink_crash = p_intact * init_vals surface_crash = (1 - p_intact) * init_vals # Useful things for later plotting (xSource, ySource) = m(source.lon, source.lat) (xTarget, yTarget) = m(target.lon, target.lat) aptCoords = [(p.lon, p.lat) for p in airports] aptCoords = np.array(aptCoords) xA, yA = m(aptCoords[:,0], aptCoords[:,1]) # Calculate the likelihood that a search plane finds a crash at # each location sp_find_prob = search_plane_probabilities(dim_m, surface_crash, sink_crash, depth_m) sb_find_prob = search_vessel_probabilities(dim_m, surface_crash, sink_crash) # Calculate the price to search each area price_per_prob_sp = costs_sp / sp_find_prob price_per_prob_sb = costs_sb / sp_find_prob sp_mean = price_per_prob_sp[np.where(np.logical_not(np.isinf(price_per_prob_sp)))].mean() sb_mean = price_per_prob_sb[np.where(np.logical_not(np.isinf(price_per_prob_sb)))].mean() print(sp_mean) print(sb_mean) price_per_prob_sp[np.where(np.isinf(price_per_prob_sp))] = sp_mean price_per_prob_sb[np.where(np.isinf(price_per_prob_sb))] = sb_mean ## Plot # Set up the figure fig = plt.figure(figsize=(8,8)) ax = fig.add_axes([0.1,0.1,0.8,0.8]) m.fillcontinents(zorder=1) m.drawcoastlines() m.drawcountries() parallels = np.arange(0.,90,10.) #m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10) # Draw the line representing the flight m.plot([xSource, xTarget], [ySource, yTarget], lw=4, c='black', zorder=4) # Draw dots on airports m.scatter(xA, yA, s=80, marker='^', color='purple', zorder=5) # Draw a contour map of costs lons, lats = m.makegrid(lat_res, lon_res) x, y = m(lons, lats) #cs = m.contourf(x, y, depth_m, 50, cmap='Blues_r') #pc = m.pcolormesh(x, y, depth_m) print(price_per_prob_sp.max()) print(price_per_prob_sp.min()) pc = m.pcolormesh(x, y, price_per_prob_sb, cmap='YlOrRd_r',vmax=5e6) #cbar = m.colorbar(pc,location='bottom',pad="5%", ticks = [0, init_vals.max()]) cbar = m.colorbar(pc,location='bottom',pad="5%") #plt.title("Distribution of undirected crashes") plt.show() return # Draw a contour map of probabilities p_x = np.linspace(dim_m.x_min, dim_m.x_max, dim_m.x_res) p_y = np.linspace(dim_m.y_min, dim_m.y_max, dim_m.y_res) x, y = np.meshgrid(p_x, p_y) ''' cs = m.contourf(x, y, u_m, cmap="blues") cbar = m.colorbar(cs,location='bottom',pad="5%") ''' # Allow the probabilities to flow in the current current_mapping = generate_current_mapping(dim_m, U_m, V_m, 1.0/10) curr_probs = init_vals.copy() maxInitProb = init_vals.max() * 1.2 for iDay in range(100): curr_probs = sink_crash + surface_crash # Calculate the likelihood that a search plane finds a crash at # each location sp_find_prob = search_plane_probabilities(dim_m, surface_crash, sink_crash, depth_m) sb_find_prob = search_vessel_probabilities(dim_m, surface_crash, sink_crash) # Calculate the price to search each area price_per_prob_sp = costs_sp / sp_find_prob price_per_prob_sb = costs_sb / sp_find_prob #price_per_prob_sp = mask_vals(dim_m, price_per_prob_sp, m, fill=10000) #print(price_per_prob_sp.min()) #price_per_prob_sp[np.where(np.isinf(price_per_prob_sp))] = float('NaN') #print(price_per_prob_sp.max()) # Plotting stuff if(iDay % 5 == 0): fig = plt.figure(figsize=(8,8)) ax = fig.add_axes([0.1,0.1,0.8,0.8]) m.plot([xSource, xTarget], [ySource, yTarget], lw=4, c='black', zorder=4) m.scatter(xA, yA, s=80, marker='^', color='purple', zorder=5) m.fillcontinents(zorder=1) m.drawcoastlines() m.drawcountries() parallels = np.arange(0.,90,10.) m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10) #cs = m.contourf(x, y, curr_probs, 50, cmap="YlOrRd", vmin=0, vmax=maxInitProb) #cs = m.pcolormesh(x, y, curr_probs, cmap="YlOrRd", vmin = 0, vmax=maxInitProb) cs = m.pcolormesh(x, y, curr_probs, cmap="YlOrRd", vmax = maxInitProb) #cs = m.pcolormesh(x, y, depth_m, cmap="bone") cbar = m.colorbar(cs,location='bottom',pad="5%") #Q = m.quiver(x, y, U_m, V_m) plt.show() # Update the probabilities surface_crash = apply_current_mapping(dim_m, surface_crash, current_mapping, m)
ax.format_coord = format_coord m.drawcoastlines() m.drawcountries() m.drawparallels(np.linspace(m.llcrnrlat, m.urcrnrlat, parallelres), labels=[True, False, False, False]) m.drawmeridians(np.linspace(m.llcrnrlon, m.urcrnrlon, meridianres), labels=[False, False, False, True]) m.drawstates() x = np.linspace(0, m.urcrnrx, dim[1]) y = np.linspace(0, m.urcrnry, dim[2]) xx, yy = np.meshgrid(x, y) quad = m.pcolormesh(xx, yy, np.transpose(np.squeeze(ftledata[timestep, :, :])), shading='gouraud', cmap='viridis') #quad = m.contourf(xx,yy, np.transpose(np.squeeze(ftledata[timestep,:,:])),shading='gouraud',cmap='viridis') cbar = fig.colorbar(quad, ax=ax, pad=0.01) ax.set_title('Time Step {0}'.format(timestep)) ridges = m.contour(xx, yy, np.transpose(np.squeeze(ftledata[timestep, :, :])), levels=[-1]) canvas = FigureCanvasTkAgg(fig, root) canvas.show() canvas.get_tk_widget().grid(row=1, column=3, rowspan=40) toolbar_frame = tk.Frame(root)
class Figure(): """ Figure is an object containing data to plot and map options. It enables to easily draw a map with data on it. """ def __init__(self, figure: plt.Figure, ax: plt.Axes, dataset: nc.Dataset, map_options: dict, presets: dict): self.figure = figure self.ax = ax self.presets = presets self.map_options = map_options self.map_settings = self._get_map_settings() self.map = Basemap(ax=self.ax, **self.map_settings) self.map.drawmapboundary(fill_color='aqua') self.map.drawcoastlines() if self.map_options['countries']: self.map.drawcountries() if self.map_options['rivers']: self.map.drawrivers() # Extract longitude and latitude arrays (try 2 different name formats) try: self.lons = np.ma.getdata(dataset['lon'][:]) self.lats = np.ma.getdata(dataset['lat'][:]) except: self.lons = np.ma.getdata(dataset['longitude'][:]) self.lats = np.ma.getdata(dataset['latitude'][:]) self.data = self._retrieve_data_from_dataset(dataset) self.transform_data() def _get_map_settings(self): """ Return the basemap kwargs from global map options. """ settings = self.presets[self.map_options['preset']]['args'].copy() settings['resolution'] = self.map_options['resolution'] return settings def _retrieve_data_from_dataset(self, dataset: nc.Dataset): """ Extract data from the dataset and process it. """ if self.map_options['pl_index'] is not None: data = dataset[self.map_options['variable']][ self.map_options['time_index'], self.map_options['pl_index'], :, :] else: data = dataset[self.map_options['variable']][ self.map_options['time_index'], :, :] data = data * self.map_options['coef'] + self.map_options['offset'] return data def transform_data(self): """ Transform the data. """ lon_offset = self.map_options['lon_offset'] self.lons = self.lons + lon_offset temp = self.data[:, 0:720].copy() self.data[:, 0:720] = self.data[:, 720:1440].copy() self.data[:, 720:1440] = temp def adapt_coordinates(self): """ Adapt coordinates to the chosen projection. """ x, y = np.meshgrid(self.lons, self.lats) xx, yy = self.map(x, y) xx[~np.isfinite(xx)] = -180 yy[~np.isfinite(yy)] = 0 return xx, yy def plot_data(self): """ Plot data on the map. """ lon, lat = self.adapt_coordinates() if self.map_settings['projection'] == "ortho": self.data[lon > 1e20] = np.nan self.data[lat > 1e20] = np.nan self.data[lon < -1e20] = np.nan self.data[lat < -1e20] = np.nan if self.map_options['norm']: norm = display_tools.MidpointNormalize( vmin=self.map_options['c_min'], vmax=self.map_options['c_max'], midpoint=self.map_options['midpoint']) else: norm = None mesh = self.map.pcolormesh(lon, lat, self.data, cmap=self.map_options['cmap'], norm=norm) if self.map_options['colorbar']: divider = make_axes_locatable(self.ax) cax = divider.append_axes("right", size='3%', pad=0.1) plt.colorbar(mappable=mesh, ax=self.ax, cax=cax, orientation='vertical', extend='both')
for k in range(0, 699): for d in range(0, 600): temp_c[j,k,d] = t2[j,k,d] - 273.15 temp_c90[j, k, d] = t290[j, k, d] - 273.15 diff[j,k,d] = temp_c90[j,k,d] - temp_c[j,k,d] datevar = num2date(time[:], units='hours since 1970-01-01 00:00:00', calendar='standard') # print(datevar[:]) map = Basemap(projection='merc', llcrnrlon=lons[0], llcrnrlat=lats[0], urcrnrlon=lons[599], urcrnrlat=lats[698], resolution='i') # map.drawcoastlines() # map.drawstates() # map.drawcountries() # map.drawlsmask(land_color='Linen', ocean_color='#CCFFFF') lon2, lat2 = np.meshgrid(lons, lats) x, y = map(lon2, lat2) plt.figure(figsize=(601/100, 700/100)) plt.gca().set_axis_off() plt.subplots_adjust(top=1, bottom=0, right=1, left=0, hspace=0, wspace=0) plt.margins(0, 0) #plt.colorbar(label="Temperature (Celsius)") for b in range(0, 24): map.pcolormesh(x, y, diff[b, :, :], cmap='bwr', vmin=-6, vmax=6) #plt.title('2m Temperature on %s' % datevar[b]) plt.savefig("E:/elise/Documents/UVA-Climate-Lab-/diurnal/ta2m_diurnal_mean_diff_2090-2099_%s.png" % b, transparent='True', bbox_inches='tight', pad_inches=0) print('saved %s' % b) plt.colorbar(label="Difference in Temperature (Celsius)") plt.savefig("E:/elise/Documents/UVA-Climate-Lab-/diurnal/ta2m_diurnal_mean_diff_2090-2099_KEY_%s.png" % b, transparent='True', bbox_inches='tight', pad_inches=0)
# Handle scale offset attrs = data.attributes(full=1) scale = attrs['slope'] offset = attrs['intercept'] dataf = dataf*scale[0] + offset[0] # Draw an equidistant cylindrical projection using the low resolution # coastline database. m = Basemap(projection='cyl', resolution='l', llcrnrlat=-90, urcrnrlat = 90, llcrnrlon=-180, urcrnrlon = 180) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(-90, 91, 45)) m.drawmeridians(np.arange(-180, 180, 45), labels=[True,False,False,True]) m.pcolormesh(longitude, latitude, dataf, latlon=True) # Draw color bar. cb = m.colorbar() ua = attrs['units'] units = ua[0] # Remove garbage character at the end. cb.set_label('Unit: '+units[:-1]) # Draw title. lna=attrs["long_name"] long_name = lna[0] # Remove garbage character at the end. plt.title('{0}\n {1}'.format(FILE_NAME, long_name[:-1])) fig = plt.gcf()
data = np.ma.masked_invalid(data) # Get the lat/lon data lon, lat = response[0].getLatLonCoords() lon, lat = m(lon, lat) # Initialize figure size (48,27) for 4K and (24,15) for 1080p #plt.figure(num=None, figsize=(24,15), dpi=80) fig = plt.figure(num=None, figsize=(8, 5), dpi=80) # Add radar data cmap = radarColors m.pcolormesh(lon, lat, data, cmap=cmap, vmin=-30, vmax=85, alpha=0.5, zorder=3) # Add date/time stamp timestamp = time.strftime( '%a %x %I:%M %p %Z', time.localtime( calendar.timegm( time.strptime(str(times[x].validPeriod.end), "%Y-%m-%d %H:%M:%S")))) plt.annotate(timestamp, xy=(0.01, 0.01), xycoords='axes fraction', fontsize=10,
llcrnrlat=-65, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180, resolution='c') #map.drawcoastlines() x, y = map(lon2, lat2) map.drawcoastlines() map.drawcountries() map.drawmapboundary() #print iyield2 cs = map.pcolormesh(x, y, iyield1, cmap=plt.cm.jet, norm=colors.PowerNorm(gamma=1. / 2.), vmin=0, vmax=16) #cbar = map.colorbar(cs,location='bottom',size="5%",pad="2%") #cbar.ax.tick_params(labelsize=15) plt.axis('off') cmap = plt.cm.bwr bounds = [-30, -25, -20, -15, -10, -5, 0, 20, 40, 60, 80, 100, 120] norm = colors.BoundaryNorm(bounds, cmap.N) #norm = colors.Normalize(vmin=-150, vmax=150) #norm=colors.SymLogNorm(linthresh=2, linscale=1,vmin=-200,vmax=200) ax2 = fig.add_subplot(422) #ax2.set_title("CESM-ISAM Maize Yield (t/ha)",fontsize=20)
def mapDraw(flnm, titlTxt=None, barTxt=None, fignm=None, projMap='cea', scale=1.0, log=False, maskNum=None, vMin=None, vMax=None, cmNm='terrain_r', lut=None, split=None): from mpl_toolkits.basemap import Basemap from numpy import ma from matplotlib.colors import LogNorm inproj = osr.SpatialReference() if type(flnm) is str: #GDAL recongnized GIS data print 'Input data: GIS dataset.' if fignm is None: fignm = flnm + '.png' if titlTxt is None: titlTxt = flnm print 'Plotting map from', flnm, 'to', fignm # Read the data and metadata ds = gdal.Open(flnm) data = GIS.read(flnm) * scale gt = ds.GetGeoTransform() proj = ds.GetProjection() xres = gt[1] yres = gt[5] # get the edge coordinates and add half the resolution # to go to center coordinates xmin = gt[0] + xres * 0.5 xmax = gt[0] + (xres * ds.RasterXSize) - xres * 0.5 ymin = gt[3] + (yres * ds.RasterYSize) + yres * 0.5 ymax = gt[3] - yres * 0.5 ds = None # create a grid of xy coordinates in the original projection inproj.ImportFromWkt(proj) elif type(flnm) is np.ndarray: print 'Input data: CLM dataset.' xmin, xres, xmax = [-180 + 1.25 / 2, 1.25, 180 - 1.25 / 2] ymin, yres, ymax = [ -90 + 180.0 / (193 * 2), -180.0 / 193, 90 - 180.0 / (193 * 2) ] ##### CLM: 0~360 =====> -180~180 inproj.ImportFromEPSG(4326) data = np.hstack([flnm[:, 288 / 2:], flnm[:, :288 / 2]]) del flnm else: print 'Input data type', type(flnm), 'not recongised.' return False import matplotlib.pyplot as plt fig = plt.figure() m = Basemap(projection=projMap, llcrnrlat=ymin, urcrnrlat=min(ymax, 90), llcrnrlon=xmin, urcrnrlon=xmax, resolution='c') #extent m.drawcountries(linewidth=.1) m.drawcoastlines(linewidth=.2) m.drawparallels(np.arange(-60, 60, 30), labels=[1, 0, 0, 0], linewidth=.3, color='grey') m.drawmeridians(np.arange(-180, 180, 30), labels=[0, 0, 1, 0], linewidth=.3, color='grey') xy_source = np.mgrid[xmin:xmax + xres:xres, ymax + yres:ymin:yres] outproj = osr.SpatialReference() outproj.ImportFromProj4(m.proj4string) xx, yy = GIS.cordConv(xy_source, inproj, outproj) # plot the data (first layer) if split is not None: lut = len(split) - 1 dump = np.zeros(data.shape) * np.NaN for j in range(len(split)): dump[data >= split[j]] = j data = dump colmap = plt.cm.get_cmap(cmNm, lut) colmap.set_bad('w') if maskNum is not None: data[data == maskNum] = np.nan if log is True: if vMin is None: vMin = np.max([np.nanmin(data), 0.01]) if vMax is None: vMax = 10**np.ceil(np.log10(np.nanmax(data))) im = m.pcolormesh(xx, yy, ma.array(data.T, mask=np.isnan(data.T)), cmap=colmap, norm=LogNorm(vmin=vMin, vmax=vMax)) else: if vMin is None: vMin = np.min(data[np.isfinite(data)]) if vMax is None: vMax = np.max(data[np.isfinite(data)]) im = m.pcolormesh(xx, yy, ma.array(data.T, mask=np.isnan(data.T)), cmap=colmap, vmin=vMin, vmax=vMax) ax = plt.gca() from mpl_toolkits.axes_grid1 import make_axes_locatable divider = make_axes_locatable(ax) cax = divider.append_axes('right', size="5%", pad=0.05) cbar = plt.colorbar(im, cax=cax) if split is not None: tick_temp = np.arange(len(split) + 1) cbar.set_ticks(tick_temp) string = [] for l in range(len(split)): string.append(str(split[l])) cbar.set_ticklabels(string) if barTxt is not None: cbar.set_label(barTxt) #cbar.update_ticks() plt.savefig(fignm, dpi=500) plt.close()
map.drawcoastlines() map.drawcountries() map.drawmapboundary() lone,late = N.meshgrid(lonnc,latnc) #Returns coordinate matrices from coordinate vectors x,y = map(lone,late) ncvar_maizef=maskoceans(x,y,ncvar_maizef) ncvar_maizef=ma.filled(ncvar_maizef, fill_value=0.) ncvar_maizef = ma.masked_where(ncvar_maizef<=0,ncvar_maizef) ncvar_maizef = ma.masked_where(mask_clm<=0,ncvar_maizef) #print maskus_new m3y=ncvar_maizef cs = map.pcolormesh(x,y,m3y,cmap=plt.cm.YlGn,vmin=0,vmax=16) cbar = map.colorbar(cs,location='bottom',size="5%",pad="2%") cbar.ax.tick_params(labelsize=15) plt.axis('off') plt.savefig('maiirrm3.jpg',dpi=300,bbox_inches='tight') fig = plt.figure(figsize=(20,15)) ax2 = fig.add_subplot(321) ax2.set_title("ISAM-CESM Maize Yield (t/ha)",fontsize=20) map = Basemap(projection ='cyl', llcrnrlat=-65, urcrnrlat=90,llcrnrlon=-180, urcrnrlon=180, resolution='c') #map = Basemap(projection='robin',lon_0=0,resolution='c') map.drawcoastlines() map.drawcountries() map.drawmapboundary()
lons = np.linspace(float(grb['longitudeOfFirstGridPointInDegrees']), float(grb['longitudeOfLastGridPointInDegrees']), int(grb['Ni']) ) #generate x coordinates normalized to the range of data lats = np.linspace(float(grb['latitudeOfFirstGridPointInDegrees']), float(grb['latitudeOfLastGridPointInDegrees']), int(grb['Nj']) ) #generate y coordinates normalized to the range of data # need to shift data grid longitudes from (0..360) to (-180..180)? (do not use for LIS, do not use for GFS) # data, lons = shiftgrid(180., data, lons, start=False) # use this to bump data from 0..360 on the lons to -180..180 grid_lon, grid_lat = np.meshgrid(lons, lats) #regularly spaced 2D grid print("Adj Lon Range: " + str(grid_lon[0,0]) + " --> " + str(grid_lon[0,-1])) #print("Data test: " , data[-102.210999:43.824593,40:50].T) plt.figure(figsize=(12,8)) m = Basemap( projection='lcc', resolution='c', rsphere=(6378137.00,6356752.3142), llcrnrlon=-108.0, urcrnrlon=-92.50, llcrnrlat=38.0, urcrnrlat=50., lat_1=33., lat_2=45, lat_0=39, lon_0=-96.) x, y = m(grid_lon, grid_lat) cs = m.pcolormesh(x,y,data,shading='flat',cmap=plt.cm.gist_stern_r) #m.readshapefile('/mnt/d/Libraries/Documents/Scripts/LIS_Plot/Test_Data/Aux_files/States_21basic/states', 'states') #m.readshapefile('/mnt/d/Libraries/Documents/Scripts/LIS_Plot/Test_Data/Aux_files/Canada/Canada', 'Canada') m.drawcoastlines() m.drawmapboundary() m.drawparallels(np.arange(-90.,120.,30.),labels=[1,0,0,0]) m.drawmeridians(np.arange(-180.,180.,30.),labels=[0,0,0,1]) plt.colorbar(cs,orientation='vertical', shrink=0.5) plt.title('SPoRT LIS: RSM 0-10cm') # Set the name of the variable to plot plt.savefig(grib +'.png') # Set the output file name
# longitudes go from 20 to 380. topodat = np.loadtxt('etopo20data.gz') lons = np.loadtxt('etopo20lons.gz') lats = np.loadtxt('etopo20lats.gz') lons, lats = np.meshgrid(lons, lats) print('min/max etopo20 data:') print(topodat.min(),topodat.max()) # create new figure fig=plt.figure() # setup cylindrical equidistant map projection (global domain). m = Basemap(llcrnrlon=-180.,llcrnrlat=-90,urcrnrlon=180.,urcrnrlat=90.,\ resolution='c',area_thresh=10000.,projection='cyl') # plot image over map. im = m.pcolormesh(lons,lats,topodat,cmap=cmap,latlon=True) m.colorbar() # draw colorbar m.drawcoastlines() # draw parallels m.drawparallels(np.arange(-90,90,30),labels=[1,0,0,1]) # draw meridians m.drawmeridians(np.arange(0,360,60),labels=[1,0,0,1]) plt.title('Cylindrical Equidistant') print('plotting Cylindrical Equidistant example ...') print(m.proj4string) # create new figure fig=plt.figure() # setup miller cylindrical map projection. m = Basemap(llcrnrlon=-180.,llcrnrlat=-90,urcrnrlon=180.,urcrnrlat=90.,\ resolution='c',area_thresh=10000.,projection='mill')
u = vars['eastward_vel'][time, :, :] v = vars['northward_vel'][time, :, :] lon = vars['lon'][:] lat = vars['lat'][:] downsamp = 25 ref_lat = lat.mean() ref_lon = lon.mean() lon, lat = np.meshgrid(lon, lat) x, y = lonlat2m(lon=lon, lat=lat, ref_lon=ref_lon, ref_lat=ref_lat) im = m.pcolormesh(lon, lat, species, vmin=c_min, vmax=c_max, latlon=True, cmap='Greys', shading='gouraud') flow_y = r_r[k] flow_x = r_r[k + 3] for p in range(len(flow_x)): x = flow_x[p] y = flow_y[p] if len(x) > 6: m.plot(x, y, 'r-') #, latlon=True) flow_y = a_r[k] flow_x = a_r[k + 3] for p in range(len(flow_x)):
inproj = osr.SpatialReference() inproj.ImportFromWkt(proj) outproj = osr.SpatialReference() outproj.ImportFromProj4(m.proj4string) mycmap = matplotlib.colors.LinearSegmentedColormap.from_list( "", ["darkblue", "yellow", "darkred"]) xx, yy = convertXY(xy_source, inproj, outproj) colors = ["darkblue", "yellow", "darkred"] im1 = m.pcolormesh(xx, yy, z.T, cmap=matplotlib.colors.ListedColormap(colors), vmin=1, vmax=3, zorder=3) arrnames = np.array(["Low", "Low", "Medium", "High"]) formatter = plt.FuncFormatter(lambda val, loc: arrnames[val]) cbar = m.colorbar(im1, location='bottom', pad="5%", size="5%", ticks=[0, 1, 2, 3], format=formatter) cbar.set_label('Exposure', size="28", labelpad=20) plt.show()
#v = np.linspace( -0.8, 0.8, 17, endpoint=True) #norm = colors.BoundaryNorm(boundaries=v, ncolors=256) #strd ax = plt.subplot2grid((4,6), (1,0)) m = Basemap(projection='cyl', llcrnrlat=-45.0, llcrnrlon=110.0, urcrnrlat=-5.0, urcrnrlon=160.0) m.drawcoastlines() m.drawparallels(np.array([-45, -35, -25, -15, -5]), labels=[1,0,0,0], fontsize=7) m.drawmeridians(np.array([110, 120, 130, 140, 150, 160]), labels=[0,0,0,1], fontsize=7) lon, lat = np.meshgrid(lon,lat) xi,yi = m(lon,lat) mn_strd_nino = np.ma.masked_invalid(mn_strd_nino) ss_strd_nino = np.ma.masked_invalid(ss_strd_nino) v = np.linspace( -26, 26, 27, endpoint=True) norm = colors.BoundaryNorm(boundaries=v, ncolors=256) mymap= m.pcolormesh(xi, yi, mn_strd_nino, norm=norm, cmap='bwr') ss = m.pcolor(xi, yi, ss_strd_nino, hatch='...', norm=norm, cmap='bwr') cb = m.colorbar(mymap,"right", size="5%", pad="2%", ticks=v) cb.ax.tick_params(labelsize=6) for label in cb.ax.yaxis.get_ticklabels()[1::2]: label.set_visible(False) cb.set_label('$W/m^2$', fontsize=8) plt.title('Longwave downwards', fontsize=10) ax.set_ylabel('El Nino', labelpad=20) ax = plt.subplot2grid((4,6), (2,0)) m = Basemap(projection='cyl', llcrnrlat=-45.0, llcrnrlon=110.0, urcrnrlat=-5.0, urcrnrlon=160.0) m.drawcoastlines() m.drawparallels(np.array([-45, -35, -25, -15, -5]), labels=[1,0,0,0], fontsize=7) m.drawmeridians(np.array([110, 120, 130, 140, 150, 160]), labels=[0,0,0,1], fontsize=7) mn_strd_nina = np.ma.masked_invalid(mn_strd_nina)
for i in xrange(dimy): for j in xrange(dimx): if finalmatrix[i][j] == 2: cb[i][j] = 1 else: cb[i][j] = 0 #this is necessary!!! #cb = np.flipud(cb) #print np.sum(cb) ################ #plotting time!# ################ #make our lon and lat 2D lon1, lat1 = np.meshgrid(lon, lat) m = Basemap(resolution='l', projection='merc', \ llcrnrlon=90, llcrnrlat=-20, urcrnrlon=150, urcrnrlat=20) #for mercator #draw map coastline, etc m.drawcoastlines(linewidth=0.25) m.drawcountries(linewidth=0.25) #finishing plt.title('Pendeteksi Awan CB ver 1.0') cs = m.pcolormesh(lon1, lat1, np.squeeze(cb), cmap='Set3', latlon=True) #cbar = m.colorbar(cs, location='bottom', pad="10%") #add color bar plt.show()
def plot_field(path, image_outpath, unitlabel, product_name): """ :return: """ """ creates single frame (from one flepart output file) time step is given by the file spatial domain is given by lon0, lon1, lat0, lat1, z0, z1 |-----------------lon1, lat1 | | | | lon0, lat0 ---------------| z0 is lower vertica level, z1 is the upper Developer note..: For most map projections, the map projection region can either be specified by setting these keywords: Keyword Description llcrnrlon longitude of lower left hand corner of the desired map domain (degrees). llcrnrlat latitude of lower left hand corner of the desired map domain (degrees). urcrnrlon longitude of upper right hand corner of the desired map domain (degrees). urcrnrlat latitude of upper right hand corner of the desired map domain (degrees). or these Keyword Description width width of desired map domain in projection coordinates (meters). height height of desired map domain in projection coordinates (meters). lon_0 center of desired map domain (in degrees). lat_0 center of desired map domain (in degrees). resolution: c (crude), l (low), i (intermediate), h (high), f (full) more at http://matplotlib.org/basemap/api/basemap_api.html """ d = scipy.io.loadmat(path) numxgrid = d["numxgrid"][0, 0] numygrid = d["numygrid"][0, 0] dxout = d["dxout"][0, 0] dyout = d["dyout"][0, 0] outlon0 = d["outlon0"][0, 0] outlat0 = d["outlat0"][0, 0] outlon1 = d["outlon1"][0, 0] outlat1 = d["outlat1"][0, 0] levels = d["levels"] time_step = d["time_step_length"][0, 0] data0 = d["data"] logging.debug("domain: %6.2f-%6.2f %6.2f %6.2f" % (outlon0, outlon1, outlat0, outlat1)) #this is better I think than the originla script lons0 = numpy.linspace(outlon0, outlon1, numxgrid) lats0 = numpy.linspace(outlat0, outlat1, numygrid) lons, lats = numpy.meshgrid(lons0, lats0) #"canvas" ready, now let's plot something steps = data0.shape[0] nuclide = path.split(os.sep)[-1].split(".")[0] if pcf.MAX_D != -999: max_d = pcf.MAX_D else: if len(data0.shape) == 4: max_d = data0[:, :, :, 0].max() elif len(data0.shape) == 3: max_d = data0[:, :, :].max() print INFO + "Processing: %s" % (nuclide) fig = plt.figure(figsize=(pcf.FIG_X, pcf.FIG_Y)) if pcf.DO_OVERLAY: #fig = plt.figure(figsize=(15,15), dpi=400) ax = fig.add_axes([0., 0., 1., 1.]) #ax = axes([0,0,1,1], frameon=False) ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) ax.set_frame_on(False) map = Basemap(projection=pcf.PROJECTION, llcrnrlon=outlon0, llcrnrlat=outlat0, urcrnrlon=outlon1, urcrnrlat=outlat1, resolution=pcf.BASEMAP_RESOLUTION, area_thresh=pcf.BASEMAP_AREA_THR, ax=ax) else: map = Basemap(projection=pcf.PROJECTION, llcrnrlon=outlon0, llcrnrlat=outlat0, urcrnrlon=outlon1, urcrnrlat=outlat1, resolution=pcf.BASEMAP_RESOLUTION, area_thresh=pcf.BASEMAP_AREA_THR) #now we create a mesh for plotting data x, y = map(lons, lats) release_start_str = rcf.SOURCE_TERM["release_start"] release_start = dt.strptime(release_start_str, rcf.DATE_FORMAT) delta_step = datetime.timedelta(seconds=rcf.SOURCE_TERM["time_step"]) c1 = False for t in range(steps): #clear the previous image, we use the same figure and Basemap instance if not pcf.DO_OVERLAY: plt.clf() if len(data0.shape) == 4: data = data0[t, :, :, 0].transpose() elif len(data0.shape) == 3: data = data0[t, :, :].transpose() if max_d > 0: log_max = math.ceil(math.log10(max_d)) levels = numpy.logspace(log_max - pcf.NUMBER_OF_ORDERS, log_max, 4 * pcf.NUMBER_OF_ORDERS + 1) #if c1: # remove old plot in OVERLAY mode # c1.remove() if data.max() > 0.: if pcf.DO_OVERLAY: ax.clear() if pcf.PLOT_METHOD == "pcolormesh": # huuuuge SVGs :( c1 = map.pcolormesh( x, y, data, #shading='gouraud', norm=LogNorm(vmin=levels[0], vmax=levels[-1]), cmap=pcf.C_MAP, alpha=pcf.ALPHA) elif pcf.PLOT_METHOD == "contourf": c1 = map.contourf( x, y, data, #shading='gouraud', levels=levels, norm=LogNorm(vmin=levels[0], vmax=levels[-1]), cmap=pcf.C_MAP, alpha=pcf.ALPHA) """ c1 = map.contour(x, y, data, #shading='gouraud', levels = levels, norm=LogNorm(vmin=levels[0], vmax=levels[-1]), cmap=pcf.C_MAP, alpha=1.0) """ elif pcf.PLOT_METHOD == "imshow": if pcf.PROJECTION != "cyl": raise ( "Cannot be used with mercator projection, uniform grid does not fit" ) else: outlon0m, outlat0m = map(outlon0, outlat0) outlon1m, outlat1m = map(outlon1, outlat1) c1 = map.imshow(data, interpolation='nearest', extent=(outlon0m, outlon1m, outlat0m, outlat1m), origin='lower', norm=LogNorm(vmin=levels[0], vmax=levels[-1]), cmap=pcf.C_MAP, alpha=pcf.ALPHA) if not pcf.DO_OVERLAY: cbar = map.colorbar(c1, location="bottom", pad="7%") cbar.set_label(unitlabel) par_step = pcf.NESTED_PAR_STEP mer_step = pcf.NESTED_MER_STEP if not pcf.DO_OVERLAY: parallels = numpy.arange(-90., 90., par_step) map.drawparallels(parallels, labels=[True, False, False, True], fontsize=10) # draw meridians meridians = numpy.arange(-180.0, 180.0, mer_step) map.drawmeridians(meridians, labels=[True, False, False, True], fontsize=10) map.drawcoastlines() map.drawcountries() out_fname = nuclide + "_t=%3.3d" % t date = release_start + t * delta_step if not pcf.DO_OVERLAY: plt.title(product_name + " of " + nuclide + " " + date.strftime("(%Y-%m-%d %H:%M)")) if pcf.PDFS_FLAG: #pdfs will be also saved out_fname += ".pdf" if pcf.JPGS_FLAG: #produce JPGs? out_fname += ".jpeg" if pcf.PNGS_FLAG: #produce PNGs? out_fname += ".png" if pcf.SVGS_FLAG: #produce PNGs? out_fname += ".svg" print "Saving to ", image_outpath + os.sep + out_fname if pcf.TIGHT_LAYOUT or pcf.DO_OVERLAY: plt.savefig(image_outpath + os.sep + out_fname, bbox_inches='tight', pad_inches=0, transparent=True) else: plt.savefig(image_outpath + os.sep + out_fname, transparent=True) if pcf.DO_OVERLAY: create_colorbar(c1, nuclide, image_outpath, unitlabel) plt.close(fig)
ticks=np.arange(-0,7,1)) #cb = mpl.colorbar.ColorbarBase(ax2, cmap=cmap, # norm=mpl.colors.Normalize(vmin = -0.5, vmax = 6.5), # ticks=np.arange(-0,7,1)) cb.ax.set_yticklabels(['land','ocean',' ','top','lake','sink','bottom']) #print(new_mask.shape,lat_0,lon_0) m = Basemap(projection='lcc', resolution='l', rsphere=(6378137.00,6356752.3142), width=new_mask.shape[1]*1000, height=new_mask.shape[0]*1000, lat_1=30,lat_2=60, lat_0=lat_0, lon_0=lon_0,ax=ax1 ) m.drawcoastlines() m.drawcountries() m.drawstates() x = np.linspace(0, m.urcrnrx, new_mask.shape[1]) y = np.linspace(0, m.urcrnry, new_mask.shape[0]) xx, yy = np.meshgrid(x, y) m.pcolormesh(xx, yy, np.ma.masked_where(new_mask[::-1,:]==0,new_mask[::-1,:]), cmap=cmap,vmin = 0-.5, vmax = 6+.5) #plt.show() plt.savefig(out_pfsol.replace('.pfsol','_mask.png'),dpi=300)
def run(FILE_NAME): # Identify the data field. DATAFIELD_NAME = 'Range_1' if USE_GDAL: import gdal GRID_NAME = 'MODIS_Grid_1km_2D' gname = 'HDF4_EOS:EOS_GRID:"{0}":{1}:{2}'.format( FILE_NAME, GRID_NAME, DATAFIELD_NAME) gdset = gdal.Open(gname) data = gdset.ReadAsArray().astype(np.float64) # Construct the grid. x0, xinc, _, y0, _, yinc = gdset.GetGeoTransform() nx, ny = (gdset.RasterXSize, gdset.RasterYSize) x = np.linspace(x0, x0 + xinc * nx, nx) y = np.linspace(y0, y0 + yinc * ny, ny) xv, yv = np.meshgrid(x, y) # In basemap, the sinusoidal projection is global, so we won't use it. # Instead we'll convert the grid back to lat/lons. sinu = pyproj.Proj("+proj=sinu +R=6371007.181 +nadgrids=@null +wktext") wgs84 = pyproj.Proj("+init=EPSG:4326") lon, lat = pyproj.transform(sinu, wgs84, xv, yv) # Read the attributes. meta = gdset.GetMetadata() long_name = meta['long_name'] units = meta['units'] _FillValue = np.float(meta['_FillValue']) scale_factor = np.float(meta['scale_factor']) valid_range = [np.float(x) for x in meta['valid_range'].split(', ')] del gdset else: from pyhdf.SD import SD, SDC hdf = SD(FILE_NAME, SDC.READ) # Read dataset. data2D = hdf.select(DATAFIELD_NAME) data = data2D[:, :].astype(np.double) # Read geolocation dataset from HDF-EOS2 dumper output. GEO_FILE_NAME = 'lat_MOD09GA.A2007268.h10v08.005.2007272184810_MODIS_Grid_1km_2D.output' GEO_FILE_NAME = os.path.join(os.environ['HDFEOS_ZOO_DIR'], GEO_FILE_NAME) lat = np.genfromtxt(GEO_FILE_NAME, delimiter=',', usecols=[0]) lat = lat.reshape(data.shape) GEO_FILE_NAME = 'lon_MOD09GA.A2007268.h10v08.005.2007272184810_MODIS_Grid_1km_2D.output' GEO_FILE_NAME = os.path.join(os.environ['HDFEOS_ZOO_DIR'], GEO_FILE_NAME) lon = np.genfromtxt(GEO_FILE_NAME, delimiter=',', usecols=[0]) lon = lon.reshape(data.shape) # Read attributes. attrs = data2D.attributes(full=1) lna = attrs["long_name"] long_name = lna[0] vra = attrs["valid_range"] valid_range = vra[0] fva = attrs["_FillValue"] _FillValue = fva[0] sfa = attrs["scale_factor"] scale_factor = sfa[0] ua = attrs["units"] units = ua[0] invalid = np.logical_or(data > valid_range[1], data < valid_range[0]) invalid = np.logical_or(invalid, data == _FillValue) data[invalid] = np.nan data = data / scale_factor data = np.ma.masked_array(data, np.isnan(data)) m = Basemap(projection='cyl', resolution='h', llcrnrlat=-2.5, urcrnrlat=12.5, llcrnrlon=-82.5, urcrnrlon=-67.5) m.drawcoastlines(linewidth=0.5) m.drawparallels(np.arange(0, 15, 5), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(-80, -65, 5), labels=[0, 0, 0, 1]) m.pcolormesh(lon, lat, data, latlon=True) cb = m.colorbar() cb.set_label(units) basename = os.path.basename(FILE_NAME) plt.title('{0}\n{1}'.format(basename, long_name)) fig = plt.gcf() # plt.show() pngfile = "{0}.py.png".format(basename) fig.savefig(pngfile)
#plt.figure(3) m.drawcoastlines() m.drawparallels(parallels, labels=[1, 1, 0, 0], fontsize=10) m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10) lon1d = np.arange(-180, 181, 10) lat1d = np.arange(-30, 31, 10) print(lon1d) LG, LT = np.meshgrid(lon1d, lat1d) cx, cy = m(LG, LT) #CS = m.pcolormesh(cx,cy,np.nanmean(cld_array,axis=0),cmap = ('RdYlBu_r'),shading='gouraud') print(cx[1, :], cy[:, 1]) print(np.nanmean(cld_array, axis=0)[1, :]) m.pcolormesh(cx, cy, np.nanmean(cld_array, axis=0), cmap=plt.cm.jet) plt.colorbar() plt.figure(5) m.drawcoastlines() m.drawparallels(parallels, labels=[1, 1, 0, 0], fontsize=10) m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10) m.pcolormesh(cx, cy, np.nanmean(ciwv_array, axis=0), cmap=plt.cm.jet) plt.colorbar() plt.figure(2) #plt.plot(np.nanmean(np.nanmean(cld_array,axis=1),axis=1)) C = cld_array[:, 0, 9] V = ciwv_array[:, 0, 9]
mapa = Basemap(projection = 'cyl', resolution='i', llcrnrlat = lat_i, urcrnrlat = lat_f, llcrnrlon = long_i, urcrnrlon = long_f) # desenha linhas dos continentes mapa.drawcoastlines(linewidth = 1.2, zorder = 2) # desenha linhas dos paises mapa.drawcountries(linewidth = 1.2, zorder = 2) # desenha linhas dos estados mapa.drawstates(linewidth = 0.5, zorder = 2) # cor dos continentes mapa.fillcontinents(color = '#c0f772', zorder = 1) # cor do oceano mapa.drawmapboundary(fill_color = '#49c4d1', zorder = 0) # plota os dados como cores mapa.pcolormesh(xx, yy, dados_degree, cmap = 'OrRd', latlon=True, zorder = 2, alpha = 0.5) # escabala de cores cbar = plt.colorbar(orientation='horizontal', shrink=0.625, aspect=20, fraction=0.2,pad=0.02) cbar.set_label('Degree', size = 12) # titulo do mapa plt.title(mes + r'/' + ano, size = 15) # salva imagem plt.savefig(rd + '/Mapas/degree/' + ano + '/' + 'mapa' + str(numMapa % 12 + 1) + '_' + mes, bbox_inches='tight') plt.close() del dados_degree # plota betweenness