def mapper(image): fig = plt.figure() cmap = mpc.ListedColormap(palettable.colorbrewer.diverging.PiYG_5.mpl_colors) # cmap.set_bad('grey',1.) # ax = fig.add_subplot(1) plt.plot() plt.title("a. ((maxNDVI/mm AcuPrecip)/year)", loc= 'left') #set the spatial cordinates of the grid, mask the ocean and draw coastlines map = Basemap(llcrnrlon=112.0,llcrnrlat=-44.5,urcrnrlon=156.25,urcrnrlat=-10, resolution = 'h', epsg=4326) map.drawmapboundary(fill_color='grey') map.fillcontinents(color= 'none', lake_color='white') map.drawlsmask(land_color='none', ) map.drawcoastlines() map.imshow(np.flipud(image), cmap=cmap, vmin=-0.006, vmax=0.009,) # cb = plt.colorbar() #Tweaking the colorbar so the the ticks allign with the grid. cb = map.colorbar()#ticks= [-0.01, -0.0075, -0.0050, -0.00250, 0.0000, 0.0025, 0.0050, 0.0075, 0.010, 0.0125]) tick_locator = ticker.MaxNLocator(nbins=5) cb.locator = tick_locator cb.update_ticks() #add in the grid map.drawparallels(np.arange(-50, -10, 10),labels=[1,0,0,0], dashes=[1,2])#color= 'none') map.drawmeridians(np.arange(110, 156.25, 10),labels=[0,0,0,1], dashes=[1,2]) plt.show()
def sub_plot_pcolor(lons, lats, data, title=None, cmap=cm.jet, vmin=None, vmax=None, cbar=True, cbar_location='bottom', units=None, ncolors=5): if vmin is None: vmin = data.min() if vmax is None: vmax = data.max() m = Basemap(**projection) m.drawlsmask(land_color='grey', lakes=False) xi, yi = m(np.squeeze(lons), np.squeeze(lats)) sp = m.pcolormesh(xi, yi, np.squeeze(data), vmin=vmin, vmax=vmax, cmap=cmap) m.drawparallels(np.arange(-80., 81., 20.)) m.drawmeridians(np.arange(-180., 181., 20.)) m.drawcoastlines(color='k', linewidth=0.25) if title: plt.title(title, size=13) if cbar: cmap = cmap_discretize(cmap, ncolors) mappable = cm.ScalarMappable(cmap=cmap) mappable.set_array([]) mappable.set_clim(-0.5, ncolors+0.5) colorbar = m.colorbar(mappable, location=cbar_location) colorbar.set_ticks(np.linspace(0, ncolors, ncolors)) colorbar.set_ticklabels(np.linspace(vmin, vmax, ncolors)) colorbar.set_label(units) return sp
def plotMap(llcrnrlon, llcrnrlat, urcrnrlon, urcrnrlat, lons, lats, color, title): m = Basemap(projection='merc', resolution='i', llcrnrlon = llcrnrlon, llcrnrlat = llcrnrlat, urcrnrlon = urcrnrlon, urcrnrlat = urcrnrlat) m.drawcountries(linewidth=1) m.drawcoastlines(linewidth=1) m.drawlsmask() m.drawstates() m.drawrivers(linewidth=.1) plt.title((str(len(lats)))+ \ title, fontsize=12) x,y = m(lons, lats) if color == 'r': plt.hexbin(x, y, gridsize=40, cmap=plt.cm.Reds) if color == 'b': plt.hexbin(x, y, gridsize=40, cmap=plt.cm.Blues) if color == 'g': plt.hexbin(x, y, gridsize=40, cmap=plt.cm.Greens) m.scatter(lons, lats, 1, marker='o',color=color, latlon=True) plt.show()
def worldplot(self,kmeans=None,proj='merc'): """ plots customer GPS location on a map with state and national boundaries. IN kmeans (int) number of means for k-means clustering, default=None proj (string) the map projection to use, use 'robin' to plot the whole earth, default='merc' """ # create a matplotlib Basemap object if proj == 'robin': my_map = Basemap(projection=proj,lat_0=0,lon_0=0,resolution='l',area_thresh=1000) else: my_map = Basemap(projection=proj,lat_0=33.,lon_0=-125.,resolution='l',area_thresh=1000., llcrnrlon=-130.,llcrnrlat=25,urcrnrlon=-65., urcrnrlat=50) my_map.drawcoastlines(color='grey') my_map.drawcountries(color='grey') my_map.drawstates(color='grey') my_map.drawlsmask(land_color='white',ocean_color='white') my_map.drawmapboundary() #my_map.fillcontinents(color='black') x,y = my_map(np.array(self.data['lon']),np.array(self.data['lat'])) my_map.plot(x,y,'ro',markersize=3,alpha=.4,linewidth=0) if kmeans: # k-means clustering algorithm---see wikipedia for details data_in = self.data.drop(['id','clv','level'],axis=1) # vq is scipy's vector quantization module output,distortion = vq.kmeans(data_in,kmeans) x1,y1 = my_map(output[:,1],output[:,0]) my_map.plot(x1,y1,'ko',markersize=20,alpha=.4,linewidth=0) plt.show() return output
def ResearchRegion_surface(): """ 在地图上画出柱表面混合比图 :return: """ fig = plt.figure(figsize=(11, 8), facecolor="white") # data = np.loadtxt('seasonAvr_data/SurfaceMixingRatio/1_seasonAvr.txt') data = np.loadtxt("allYearAvr_data/SurfaceMixingRatio/allYearAvr.txt") arr = np.zeros((180, 360)) for i in range(180): arr[i, :] = data[179 - i, :] longitude = np.loadtxt("lonlat_data/longitude.txt") latitude = np.loadtxt("lonlat_data/latitude.txt") m = Basemap(llcrnrlon=70, llcrnrlat=15, urcrnrlon=138, urcrnrlat=55, projection="mill", resolution="h") m.drawparallels(np.arange(5.5, 90.5, 1.0), color="w", linewidth=0.5, dashes=[1, 1], labels=[0, 0, 0, 0]) m.drawmeridians(np.arange(60.5, 181.5, 1.0), color="w", linewidth=0.5, dashes=[1, 1], labels=[0, 0, 0, 0]) m.drawmapboundary(fill_color="0.3") m.readshapefile("shp/CHINA", "CHINA", drawbounds=1, color="black") topo = maskoceans(longitude, latitude, arr) im = m.pcolormesh(longitude, latitude, topo, shading="flat", cmap=plt.cm.jet, latlon=True, vmin=0, vmax=500) m.drawlsmask(ocean_color="w", lsmask=0) cbar = m.colorbar() cbar.ax.set_ylabel("SurfaceMixingRatio", color="black", fontsize="14", rotation=90) plt.show()
def lambert_conformal(request): import matplotlib from mpl_toolkits.basemap import Basemap import numpy as np from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure width = float(request.GET.get('width', 6000000)) height = float(request.GET.get('height', 4500000)) lat = float(request.GET.get('lat',-7)) lon = float(request.GET.get('lon',107)) true_lat1 = float(request.GET.get('true_lat1',5)) true_lat2 = float(request.GET.get('true_lat2',5)) m = Basemap(width=width,height=height, rsphere=(6378137.00,6356752.3142),\ resolution=None,projection='lcc',\ lat_1=true_lat1,lat_2=true_lat2,lat_0=lat,lon_0=lon) fig = Figure() canvas = FigureCanvas(fig) m.ax = fig.add_axes([0, 0, 1, 1]) m.drawlsmask(land_color='gray',ocean_color='white',lakes=True) m.drawparallels(np.arange(-90.,91.,30.), color='black') m.drawmeridians(np.arange(-180.,181.,60.), color='black') x, y = m(lon, lat) m.plot(x, y, 'ro') response = HttpResponse(content_type='image/png') canvas.print_figure(response, dpi=100) return response
def mapfig(ax=plt.gca()): m = Basemap(projection='merc',llcrnrlat=-25,urcrnrlat=8,llcrnrlon=-15,urcrnrlon=18,resolution='l',ax=ax) m.drawcoastlines() #m.drawmeridians(np.linspace(-17,11,8),labels=[0,0,0,1],linewidth=0.1) #m.drawparallels(np.linspace(-18,4,12),labels=[1,0,0,0],linewidth=0.1) m.drawlsmask(land_color='lightgrey',ocean_color='None',lakes=True) #m.shadedrelief(alpha=0.4) return m
def make_map(): from mpl_toolkits.basemap import Basemap m=Basemap(llcrnrlon=-125,llcrnrlat=31,urcrnrlon = -102.5,urcrnrlat=50,projection='cyl',lat_1=33,lat_2=42,lon_0=-110, resolution='c') m.drawcoastlines() m.drawstates() m.drawcountries() m.drawlsmask(land_color='grey',ocean_color='lightblue',lakes=True) return(m)
def n_pac_sect_2_w(): map = Basemap(width=16000000,height=9000000,rsphere=(6378137.00,6356752.3142),projection='lcc',lat_1=0.,lat_2=65,lat_0=30,lon_0=-190.,area_thresh=50000.) map.drawcoastlines() map.drawmeridians([120,150,210,240,270],dashes=[3,4]) map.drawmeridians([180],dashes=[6,4]) map.drawparallels(np.arange(-180,180,30),dashes=[3,4]) map.drawlsmask(land_color='0.8', ocean_color='w', lsmask=None, lsmask_lons=None, lsmask_lats=None, lakes=False, resolution='c', grid=10) return map
def plotDifference(lats,lons,years,thk_diff,directory): """ Makes large subplot of difference in all the SIT data between PIOMAS and the satellites [satellite - PIOMAS] """ ### Call parameters plt.rcParams['text.usetex']=True plt.rcParams['font.family'] = 'sans-serif' plt.rcParams['font.sans-serif'] = 'Avant Garde' ### Define figure fig = plt.figure() for i in xrange(len(thk_diff)): ax = plt.subplot(3,4,i+1) m = Basemap(projection='npstere',boundinglat=60,lon_0=-90, round=True,resolution='l') m.drawmapboundary(fill_color = 'white') m.drawlsmask(land_color='darkgrey',ocean_color='snow') parallels = np.arange(50,90,10) meridians = np.arange(-180,180,30) m.drawparallels(parallels,labels=[False,False,False,False], linewidth=0.25) m.drawmeridians(meridians,labels=[False,False,False,False], linewidth=0.25) thk_diff[np.where(thk_diff >= 3.)] = 3 thk_diff[np.where(thk_diff <= -3.)] = -3 cs = m.contourf(lons,lats,thk_diff[i,:,:],np.arange(-3,3.1,0.1), latlon=True,extend='both') cs.set_cmap('seismic_r') ax.text(0.89,0.95,r'\textbf{%s}' % (years[i]),size='8', horizontalalignment='center',backgroundcolor='w', verticalalignment='center',bbox=dict(facecolor='w', edgecolor='k',alpha=0.9),transform=ax.transAxes) cbar_ax = fig.add_axes([0.30,0.1,0.4,0.03]) cbar = fig.colorbar(cs,cax=cbar_ax,orientation='horizontal', extend='both',extendfrac=0.07) cbar.set_label(r'Thickness (m)') cbar.set_ticks(np.arange(-3,4,1)) cbar.set_ticklabels(map(str,np.arange(-3,4,1))) fig.suptitle(r'\textbf{SIT Difference [Satellite - PIOMAS]}',fontsize=16) plt.tight_layout() fig.subplots_adjust(bottom=0.14) fig.subplots_adjust(top=0.92) fig.subplots_adjust(wspace=-.56) fig.subplots_adjust(hspace=-0.0) plt.savefig(directory +'cs2piomas_diff.png', dpi=500) print 'Completed: Difference subplot finished!'
def n_am_ortho(): map = Basemap(projection='ortho',lon_0=-115,lat_0=90,area_thresh=50000.) map.drawcoastlines(linewidth=1,color=[.3,.9,.3]) # map.fillcontinents(color='.9') #[.91,.91,.95] map.drawmeridians(np.arange(0,360,90)) map.drawparallels(np.arange(-180,180,30)) # map.drawmapboundary(fill_color='w') map.drawlsmask(land_color='0.8', ocean_color='w', lsmask=None, lsmask_lons=None, lsmask_lats=None, lakes=False, resolution='c', grid=10) return map
def preload_map(): if not os.path.isfile(pickle_file): ip_map = Basemap(projection='robin', lon_0=0, resolution='c') ip_map.drawlsmask(ocean_color="#99ccff", land_color="#009900") ip_map.drawcountries(linewidth=0.25, color='#ffff00') ip_map.drawcoastlines(linewidth=0.25) pickle.dump(ip_map, open(pickle_file, 'wb'), -1) else: ip_map = pickle.load(open(pickle_file, 'rb')) global pickle_bytes pickle_bytes = pickle.dumps(ip_map, -1)
def map_template(): """Return template figure for the given title and date.""" fig = plt.figure(figsize=(11.69, 8.27), dpi=300) plt.text(62, -47, "wenfo.org/apwm/", ha="left", fontsize=10) plt.text(208, -47, 'Created ' + TODAY.isoformat(), ha="right", fontsize=10) m = Basemap(projection='cyl', resolution='l', llcrnrlat=-50, urcrnrlat=40, llcrnrlon=60, urcrnrlon=210) m.drawcoastlines(linewidth=0.75) m.drawcountries() m.drawlsmask(land_color=(0, 0, 0, 0), ocean_color='white', lakes=True) m.drawparallels(np.arange(-23, 24, 23), labels=[1, 0, 0, 1], linewidth=0.6, color=(0.2, 0.2, 0.2)) m.drawmeridians(np.arange(-180, 181, 30), labels=[1, 0, 0, 1], linewidth=0.6, color=(0.2, 0.2, 0.2)) return fig, m
def render_map(grb_file, llclat, llclon, urclat, urclon, altitude_layer): """Given a grb file, renders a jpg map on disk.""" print('processing file %s ' % grb_file) grbs = pygrib.open(grb_file) data = grbs.select(name='Temperature')[altitude_layer]['values'] plt.figure(figsize=(12, 12)) # We don't like the way noaa aligns things. We like monotonic variations. data = realign_noaa_data(data) lonlat2temp = interpolate.interp2d(ALL_LONS, ALL_LATS, data, kind='linear') lats_interp = np.arange(llclat, urclat, 0.01) lons_interp = np.arange(llclon, urclon, 0.01) data_interp = lonlat2temp(lons_interp, lats_interp) # Size of the img to render in meters. width, height = width_height_from_bbox(llclat, llclon, urclat, urclon) m = Basemap( projection='cass', lat_ts=10, lat_0=(urclat + llclat) / 2, lon_0=(llclon + urclon) / 2, resolution='i', width=width, height=height) x, y = m(*np.meshgrid(lons_interp, lats_interp)) # Draw plenty of fancy stuff m.drawstates() m.drawcountries() m.drawlsmask() m.drawrivers() m.drawcoastlines() m.shadedrelief() m.drawparallels(np.arange(-90., 120., 30.), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(-180., 180., 60.), labels=[0, 0, 0, 1]) m.pcolormesh( x, y, data_interp, shading='flat', cmap=plt.cm.jet, alpha=0.05, vmin=260, vmax=305) m.colorbar(location='right') plt.title('Temperature') image = '%s.jpg' % grb_file plt.savefig(image) plt.close()
def define_map_projection(projection='gall', llcrnrlat=-80, urcrnrlat=80, llcrnrlon=-180, urcrnrlon=180, resolution='i', land_color='grey', ocean_color='lightblue', lakes=True): '''Define projected map Return: the projection ''' from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt m = Basemap(projection=projection, llcrnrlat=llcrnrlat, urcrnrlat=urcrnrlat, llcrnrlon=llcrnrlon, urcrnrlon=urcrnrlon, resolution=resolution) m.drawlsmask(land_color=land_color, ocean_color=ocean_color, lakes=lakes) m.drawcoastlines(linewidth=0.75) m.drawstates(linewidth=0.5) m.drawcountries(linewidth=0.5) return m
def plot_map(res, bins, cmap, cropName, fileName, technologyName, variableName, unitLabel, techFolder): figTitle = cropName + ' ' + technologyName + ' ' + variableName + ' (' + unitLabel + ')' plt.close() plt.figtext(0.025,0.92, figTitle, clip_on = 'True', size = 'large', weight = 'semibold'); plt.figtext(0.025,0.86, 'Spatially disaggregated production statistics of circa 2005 using the Spatial Production Allocation Model (SPAM).', clip_on = 'True', size = 'x-small', stretch = 'semi-condensed', weight = 'medium'); plt.figtext(0.025,0.835,'Values are for 5 arc-minute grid cells.', clip_on = 'True', size = 'x-small', stretch = 'semi-condensed', weight = 'medium'); plt.figtext(0.025,0.072, 'You, L., U. Wood-Sichra, S. Fritz, Z. Guo, L. See, and J. Koo. 2014', clip_on = 'True', size = 'xx-small', stretch = 'semi-condensed', weight = 'medium') plt.figtext(0.025,0.051, 'Spatial Production Allocation Model (SPAM) 2005 Version 2.0.', clip_on = 'True', size = 'xx-small', stretch = 'semi-condensed', weight = 'medium') plt.figtext(0.025,0.030, '03.10.2015. Available from http://mapspam.info', clip_on = 'True', size = 'xx-small', stretch = 'semi-condensed', weight = 'medium'); plt.figimage(logos, 4100, 200) map = Basemap(projection='merc',resolution='i', epsg=4326, lat_0 = 0, lon_0 = 20, llcrnrlon=-160, llcrnrlat=-70, urcrnrlon=200, urcrnrlat=90) map.drawlsmask(land_color='#fffff0', lakes = False, zorder = 1) shp_coast = map.readshapefile(baseShpLoc + '/ne_50m_coastline/ne_50m_coastline', 'scalerank', drawbounds=True, linewidth=0.1, color = '#828282', zorder = 7) shp_rivers = map.readshapefile(baseShpLoc + '/ne_110m_rivers_lake_centerlines/ne_110m_rivers_lake_centerlines', 'scalerank', drawbounds=True, color='#e8f8ff', linewidth=0.1, zorder = 5) shp_lakes = map.readshapefile(baseShpLoc + '/ne_110m_lakes/ne_110m_lakes', 'scalerank', drawbounds=True, linewidth=0.1, color='#e8f8ff', zorder=4) paths = [] for line in shp_lakes[4]._paths: paths.append(matplotlib.path.Path(line.vertices, codes=line.codes)) coll_lakes = matplotlib.collections.PathCollection(paths, linewidths=0, facecolors='#e8f8ff', zorder=3) cs = map.pcolormesh(res.lons, res.lats, res.d2, cmap=cmap, norm=BoundaryNorm(bins, 256, clip=True), zorder = 6) map.drawcountries(linewidth=0.1, color='#828282', zorder = 8) ax = plt.gca() ax.add_collection(coll_lakes) cbar = map.colorbar(cs,location='bottom', pad='3%') if (variableName == 'Production' or variableName == 'Yield'): labelSize = 8 else : labelSize = 7 labels = [item.get_text() for item in cbar.ax.get_xticklabels()] labels[0] = '1'; labels[labelSize - 1] = labels[labelSize - 1] + ' <'; labels[labelSize] = '' cbar.ax.set_xticklabels(labels) plt.tight_layout(h_pad=0.9, w_pad = 0.9) outputFile = 'spam2005v2r0_' + techFolder + '_' + fileName + '_' + technologyName.lower() plt.savefig(outputFolder + '/' + techFolder + '/' + outputFile + '.png', format='png', dpi=900)
def maping(rawimage, rawname, image, name): import palettable import matplotlib.colors as mpc fig = plt.figure() cmap = mpc.ListedColormap(palettable.colorbrewer.diverging.PiYG_9.mpl_colors) # cmap.set_bad('grey',1.) ax = fig.add_subplot(121) ax.set_title("a. (maxNDVI/year)", loc= 'left') #set the spatial cordinates of the grid, mask the ocean and draw coastlines map = Basemap(llcrnrlon=112.0,llcrnrlat=-44.5,urcrnrlon=156.25,urcrnrlat=-10, resolution = 'h', epsg=4326) map.drawmapboundary(fill_color='grey') map.fillcontinents(color= 'none', lake_color='white') map.drawlsmask(land_color='none', ) map.drawcoastlines() map.imshow(np.flipud(rawimage), cmap=cmap, vmin=-0.01, vmax=0.0125,) map.colorbar()#ticks= [-0.01, -0.0075, -0.0050, -0.00250, 0.0000, 0.0025, 0.0050, 0.0075, 0.010, 0.0125]) #add in the grid map.drawparallels(np.arange(-50, -10, 10),labels=[1,0,0,0], dashes=[1,2])#color= 'none') map.drawmeridians(np.arange(110, 156.25, 10),labels=[0,0,0,1], dashes=[1,2]) # from palettable.colorbrewer.qualitative import Dark2_7 ax = fig.add_subplot(122) ax.set_title("b. ((maxNDVI/mmrainfall)/year)", loc= 'left') #set the spatial cordinates of the grid, mask the ocean and draw coastlines map = Basemap(llcrnrlon=112.0,llcrnrlat=-44.5,urcrnrlon=156.25,urcrnrlat=-10, resolution = 'h', epsg=4326) map.drawmapboundary(fill_color='grey') map.fillcontinents(color= 'none', lake_color='white') map.drawlsmask(land_color='none', ) map.drawcoastlines() #load the data into a figure map.imshow(np.flipud(image), cmap=cmap, vmin=-0.01, vmax=0.0125,) map.colorbar()#ticks= [-0.01, -0.0075, -0.0050, -0.00250, 0.0000, 0.0025, 0.0050, 0.0075, 0.010, 0.0125]) #add in the grid map.drawparallels(np.arange(-50, -10, 10),labels=[1,0,0,0], dashes=[1,2])#color= 'none') map.drawmeridians(np.arange(110, 156.25, 10),labels=[0,0,0,1], dashes=[1,2]) plt.show()
def cat_mapper(image, cmap, title, vmin, vmax, vmin2=False, vmax2=False, cmap2=False, norm=False, save=False): """To map things by a given number of catogeries""" fig = plt.figure() # cmap.set_bad('grey',1.) # ax = fig.add_subplot(1) plt.plot() if title is True: plt.title(title, loc= 'left') else: pass #set the spatial cordinates of the grid, mask the ocean and draw coastlines map = Basemap(llcrnrlon=112.0,llcrnrlat=-44.5,urcrnrlon=156.25,urcrnrlat=-10, resolution = 'h', epsg=4326) map.drawmapboundary(fill_color='grey') map.fillcontinents(color= 'none', lake_color='white') map.drawlsmask(land_color='none', ) map.drawcoastlines() map.drawstates() if norm == False: map.imshow(np.flipud(image), cmap=cmap, vmin=vmin, vmax=vmax) else: map.imshow(np.flipud(image), cmap=cmap, vmin=vmin, vmax=vmax, norm=norm) # cb = plt.colorbar() #Tweaking the colorbar so the the ticks allign with the grid. cb = map.colorbar()#ticks= [-0.01, -0.0075, -0.0050, -0.00250, 0.0000, 0.0025, 0.0050, 0.0075, 0.010, 0.0125]) if vmax-vmin <= 1: tick_locator = ticker.MaxNLocator(nbins=20) else: tick_locator = ticker.MaxNLocator(nbins=vmax-vmin) cb.locator = tick_locator cb.update_ticks() #add in the grid map.drawparallels(np.arange(-50, -10, 10),labels=[1,0,0,0], dashes=[1,2])#color= 'none') map.drawmeridians(np.arange(110, 156.25, 10),labels=[0,0,0,1], dashes=[1,2]) if save is not False: plt.savefig("%s/CTSR/%d/R4_paperfigures/%s.png" % (path, crn, save)) plt.show()
def plot_map(ax, yc, xc, data, Projection_Parameters, cbar_loc=False, vmin=-1, vmax=1, cmap='GrBG'): m = Basemap(**Projection_Parameters) m.drawlsmask(land_color='white', ocean_color='0.8') m.drawcoastlines() m.drawparallels(np.arange(-80, 81, 20)) m.drawmeridians(np.arange(-180, 181, 20)) xi, yi = m(xc, yc) cm = matplotlib.cm.get_cmap(cmap) m.drawlsmask(land_color='white', ocean_color='0.8') ax = m.pcolor(xi, yi, data, cmap=cm, vmin=vmin, vmax=vmax) if cbar_loc: cbar = m.colorbar(ax, location=cbar_loc) else: cbar = None return cbar
def mercator(request): import matplotlib from mpl_toolkits.basemap import Basemap import numpy as np from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure upper_lat = float(request.GET.get('upper_lat', 20)) upper_lon = float(request.GET.get('upper_lon', 145)) lower_lat = float(request.GET.get('lower_lat',-20)) lower_lon = float(request.GET.get('lower_lon',90)) true_lat = float(request.GET.get('true_lat',5)) draw_ref_point = False try: ref_lat = float(request.GET.get('ref_lat')) ref_lon = float(request.GET.get('ref_lon')) draw_ref_point = True except: pass m = Basemap(projection='merc',llcrnrlat=lower_lat,urcrnrlat=upper_lat, llcrnrlon=lower_lon,urcrnrlon=upper_lon,lat_ts=true_lat, resolution=None) fig = Figure() canvas = FigureCanvas(fig) m.ax = fig.add_axes([0, 0, 1, 1]) # m.drawcoastlines() # m.drawmapboundary(fill_color='aqua') # m.fillcontinents(color='coral',lake_color='aqua') # m.etopo() m.drawlsmask(land_color='gray',ocean_color='white',lakes=True) m.drawparallels(np.arange(-90.,91.,30.), color='black') m.drawmeridians(np.arange(-180.,181.,60.), color='black') if draw_ref_point: x, y = m(ref_lon, ref_lat) m.plot(x, y, 'ro') response = HttpResponse(content_type='image/png') canvas.print_figure(response, dpi=100) return response
def plotMap2(data2d): fig = figure(figsize=(12, 6)) # ax=fig.add_axes([0.1,-0.1,0.8,1.3]) m = Basemap(llcrnrlon=-120., llcrnrlat=20., urcrnrlon=-60., urcrnrlat=50., rsphere=(6378137.00, 6356752.3142), resolution='l', projection='merc', lat_0=40., lon_0=-20., lat_ts=0.) m.drawcoastlines() # m.fillcontinents() # draw parallels m.drawparallels(np.arange(50, 30, -10), labels=[1, 1, 0, 1]) # draw meridians m.drawmeridians(np.arange(-120, -60, 30), labels=[1, 1, 0, 1]) m.drawlsmask(land_color='Linen', ocean_color='#CCFFFF') # m.drawstates() # m.drawcountries() x, y = m(data2d[:, 0], data2d[:, 1]) # plot(x,y,'o') triang = tri.Triangulation(x, y) xmid = x[triang.triangles].mean(axis=1) ymid = y[triang.triangles].mean(axis=1) aa = [m.is_land(xm, ym) for xm, ym in zip(xmid, ymid)] mask = np.where(aa, 0, 1) triang.set_mask(mask) # tripcolor(x,y,z) tricontourf(triang, data2d[:, 2], 20) colorbar(fraction=.02, pad=0.1) # location='bottom', pad="10%") savefig('map2.eps') # show() return
def make_map(fs, label_parallels=None, label_meridians=None): """ function that creates map using Basemap. Requires fontsize, and optional arguments governing labels for parallels and meridians. Returns matplotlib plotting object. """ from mpl_toolkits.basemap import Basemap import numpy as np ## m = Basemap(llcrnrlon=-125, llcrnrlat=31, urcrnrlon=-102.5, urcrnrlat=50, projection='cyl', lat_1=33, lat_2=42, lon_0=-110, resolution='i', fix_aspect=True) # m.drawcoastlines() m.drawstates() m.drawcountries() m.drawmapboundary() m.drawparallels(np.arange(-90., 120., 10.)) # draw parallels m.drawmeridians(np.arange(0., 420., 10.)) # draw meridians if label_parallels: m.drawparallels(np.arange(-90., 120., 10.), labels=[1, 0, 0, 0], size=fs) # draw parallels if label_meridians: m.drawmeridians(np.arange(0., 420., 10.), labels=[0, 0, 0, 1], size=fs) # draw meridians m.drawlsmask(land_color='silver', ocean_color='lightblue', lakes=True, resolution='c') return (m)
def map_Arctic(lon, lat, lat0, hit): ''' ======================================================================= Create a map of Arctic in Stereographic Proj., returns the object of figure, axis and basemap frame. ----- created on 2014/12/22, Yingkai (Kyle) Sha ----------------------------------------------------------------------- fig, ax, proj = map_Arctic(...) ----------------------------------------------------------------------- Input: lon, lat: longitude and latitude records, usually nav_lon, nav_lat lat0 : bounding latitude for Arctic hit : (=1): maskland + draw parallels/meridians Output: fig, ax, proj: figure, axis, basemap object ======================================================================= ''' fig = plt.figure(figsize=(14, 14)) proj = Basemap(projection='npstere', resolution='l', boundinglat=lat0, lon_0=90, round=True) ax = plt.gca() # parallels & meridians parallels = np.arange(-90, 90, 15) meridians = np.arange(0, 360, 60) lw = 0 if hit == 1: lw = 0.5 proj.drawparallels(parallels, labels=[1, 1, 1, 1],\ fontsize=10, latmax=90, linewidth=lw) proj.drawmeridians(meridians, labels=[1, 1, 1, 1],\ fontsize=10, latmax=90, linewidth=lw) # coastline, maskland proj.drawcoastlines(linewidth=1.5, linestyle='-', color='k', zorder=3) if hit == 1: proj.drawlsmask(land_color=[0.5, 0.5, 0.5], ocean_color='None', lsmask=None, zorder=2) return fig, ax, proj
def drawAllCars(self, i=0): """ A function to draw a plot of all cars in Shanghai in 1 hour! :param i:the target hour accept 0 ~ 23 :return: None """ if i < 0 or i > 23: print('not a valid hour!') return None s = '2018-04-01 ' + str(i).zfill(2) + ':00:00' e = '2018-04-02 ' + '00' + ':00:00' start = datetime.datetime.strptime(s, '%Y-%m-%d %H:%M:%S') end = datetime.datetime.strptime(e, '%Y-%m-%d %H:%M:%S') result = self.data.filter( lambda x: x[9] >= start and x[9] <= end).collect() lons = [h[10] for h in result] lats = [h[11] for h in result] plt.figure(figsize=(15, 15)) map = Basemap(projection='merc', resolution='h', area_thresh=0.1, llcrnrlon=121.05, llcrnrlat=31.002, urcrnrlon=121.9128, urcrnrlat=31.4466) map.drawcoastlines() map.drawcountries() # map.fillcontinents(color='mistyrose',lake_color='slategrey') map.drawlsmask(land_color='slategray', ocean_color='slategray', lakes=True) # map.drawrivers(color = 'slategrey',linewidth=0.3) # map.drawmapboundary(fill_color='slategray') # lons = [h[10] for h in temp] # lats = [h[11] for h in temp] lon, lat = map(np.array(lons), np.array(lats)) map.scatter(lon, lat, color='red', s=0.0001, alpha=0.1) fig = plt.gcf() path = '/home/bigdatalab24/' + str(i) + '.png' fig.savefig(path) plt.show()
def sub_plot_pcolor(lons, lats, data, title=None, cmap=cm.jet, vmin=None, vmax=None, cbar=True, cbar_location='bottom', units=None, ncolors=5): if vmin is None: vmin = data.min() if vmax is None: vmax = data.max() m = Basemap(**projection) m.drawlsmask(land_color='grey', lakes=False) xi, yi = m(np.squeeze(lons), np.squeeze(lats)) sp = m.pcolormesh(xi, yi, np.squeeze(data), vmin=vmin, vmax=vmax, cmap=cmap) m.drawparallels(np.arange(-80., 81., 20.)) m.drawmeridians(np.arange(-180., 181., 20.)) m.drawcoastlines(color='k', linewidth=0.25) if title: plt.title(title, size=13) if cbar: cmap = cmap_discretize(cmap, ncolors) mappable = cm.ScalarMappable(cmap=cmap) mappable.set_array([]) mappable.set_clim(-0.5, ncolors + 0.5) colorbar = m.colorbar(mappable, location=cbar_location) colorbar.set_ticks(np.linspace(0, ncolors, ncolors)) colorbar.set_ticklabels(np.linspace(vmin, vmax, ncolors)) colorbar.set_label(units) return sp
def show_data_on_map(data): """Shows probes locations on map of Can. Is.""" fig = plt.figure(figsize=(8, 8)) ax = fig.add_axes([0.1, 0.05, 0.8, 0.9]) # create polar stereographic Basemap instance. m = Basemap(projection='stere',lon_0=-15.4,lat_0=28.1,lat_ts=28.1,\ llcrnrlat=26.5,urcrnrlat=29.5,\ llcrnrlon=-18.5,urcrnrlon=-13.5,\ rsphere=6371200.,resolution='l',area_thresh=10000,epsg=4326) # draw coastlines, state and country boundaries, edge of map. m.drawcoastlines() m.drawcountries() m.drawstates() m.drawlsmask(resolution='f') m.arcgisimage( server='http://server.arcgisonline.com/ArcGIS', service='ESRI_Imagery_World_2D', xpixels=400, ypixels=None, dpi=96, verbose=False, ) # draw parallels. parallels = np.arange(0., 90, 1.) m.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10) # draw meridians meridians = np.arange(180., 360., 2.) m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10) for ext in best_exts: sdata = data[ext] lat = sdata['lat'].data.copy() lon = sdata['lon'].data.copy() m.plot(lon, lat, 'o', label=ext, alpha=0.5) #ax.plot(lat,lon,'o',label=ext) handles, labels = ax.get_legend_handles_labels() ax.legend(handles, labels, loc='lower right') ax.set_title('Probes Geographical Distribution', fontsize=14) plt.show()
def surft(ax, scenario, di, lakeplist, laketable): '''draws a map of surface temperature on ax scenario: scenario dir name di: day index lakeplist: path the the lakes (under this we find the scenario) laketable: pandas.DataFrame with names latitude and longitude ** order of lakes in lakeplist and laketable needs to be the same ''' flist = [os.path.join(lp, scenario, 'Tzt.csv.gz') for lp in lakeplist] out = np.zeros(shape=(len(lakeplist), )) * np.nan for i, gzp in enumerate(flist): if i % 1000 == 0: print('... running %sth lake' % i) with gzip.open(gzp, 'rb') as gzf: for _ in xrange(di): next(gzf) line = gzf.readline() out[i] = line.split(',')[0] outfloat = map(float, out) m = Basemap(width=1.65e6, height=1.95e6, lat_0=63, lon_0=18, projection='lcc') # m.shadedrelief() m.drawlsmask(land_color='gray', ocean_color='lightblue', lakes=False, resolution='f', grid=1.25) # m.drawcoastlines() # m.drawcountries() # m.drawmapboundary(fill_color='lightgray') # m.drawmeridians(range(-10, 45, 2)) # m.drawparallels(range(50, 80, 5)) # m.fillcontinents(color='white') colours = [] alpha = 0.7 for temperature in outfloat: if temperature == 0.0: colours.append([0.9, 0.9, 0.9, alpha]), else: colours.append(mpl.cm.coolwarm(min(1, temperature/23.0), alpha=alpha)) m.scatter(laketable['longitude'].values, laketable['latitude'].values, s=np.sqrt(laketable['area'].values)/50, c=colours, marker='.', # linestyle='None', linewidths=0, latlon=True)
def plot_compare_map(lons, lats, y_true, y_predict, timestamp, s=None, cmap=None, outdir='/home/ubuntu/dataset/output/'): """ Plots the actual and predicted values side by side for comparison. """ timestamp = str(int(timestamp)) yr = timestamp[:4] mn = timestamp[4:6] dt = timestamp[6:] if cmap is None: cmap=mpl.cm.get_cmap('RdYlGn') area_thresh=25000 land_color='grey' ocean_color='lightblue' fig = plt.figure(figsize=(10,7)) plt.title('/'.join([yr, mn, dt]), loc='right', fontsize=14) plt.axis('off') ax = fig.add_subplot(2,1,1) m = Basemap(projection='cyl', llcrnrlat=lats.min(), llcrnrlon=lons.min(), urcrnrlat=lats.max(), urcrnrlon=lons.max(), resolution='f', area_thresh=area_thresh) m.scatter(lons, lats, c=y_true, edgecolor='none', cmap=cmap, s=s) m.drawlsmask(land_color=land_color, ocean_color=ocean_color, lakes=True) m.drawcountries() m.drawcoastlines() ax = fig.add_subplot(2,1,2) m = Basemap(projection='cyl', llcrnrlat=lats.min(), llcrnrlon=lons.min(), urcrnrlat=lats.max(), urcrnrlon=lons.max(), resolution='f', area_thresh=area_thresh) m.scatter(lons, lats, c=y_predict,edgecolor='none',cmap=cmap, s=s) m.drawlsmask(land_color=land_color, ocean_color=ocean_color, lakes=True) m.drawcountries() m.drawcoastlines() img_path = outdir+str(int(timestamp))+'.png' plt.savefig(img_path, bbox_inches='tight', dpi=300) return img_path
def basemap_temperature(data_comp,met): lat_ts=90.0 ; lat_0=90.0 ; lon_0=-45.0 ; sgn=1 width=7000000. ; height=7000000.0 ; vmin = 32 ; vmax = 36 ; ind = 0 if met == 5: mm = 0 elif met == 200: mm = 16 elif met == 400: mm = 21 else: print "error: wrong depth level" fig, axes = plt.subplots(2,3) for data in data_comp: m = Basemap(ax=axes.flat[ind],width=width,height=height,resolution='h',\ projection='stere',lat_ts=lat_ts,lat_0=lat_0,lon_0=lon_0) # the continents will be drawn on top. #m.drawmapboundary(fill_color='white') # fill continents, set lake color same as ocean color. #m.fillcontinents(color='grey',lake_color='navy') m.drawlsmask(land_color='grey',ocean_color='white',lakes=True) x,y=m(data_comp[data].lon,data_comp[data].lat) datam = data_comp[data].S[mm,:,:] sitm = np.ma.masked_where(np.isnan(datam),datam) CS=m.pcolormesh(x,y,sitm,cmap=cmocean.cm.salt,vmin=vmin,vmax=vmax) m.drawparallels(np.arange(-80.,81.,15.)) m.drawmeridians(np.arange(-180.,181.,30.)) #m.drawcoastlines() axes.flat[ind].set_title('Sal at '+str(met)+'m - '+data_comp[data].title) ind += 1 cbar_ax = fig.add_axes([1.9, 0.3, 0.045, 1.4]) cbar = plt.colorbar(CS, cax=cbar_ax,) cbar.ax.set_ylabel(r'$psu$') plt.delaxes(axes.flat[-1]) fig.subplots_adjust(right=1.7,top=1.8)
def plotCOColumn(): """ 在地图上画出柱浓度图 """ fig = plt.figure(figsize=(11, 8)) rect = fig.patch rect.set_facecolor("white") data = np.loadtxt("seasonAvr_data/TotalColumn/1_seasonAvr.txt") longitude = np.loadtxt("lonlat_data/longitude.txt") latitude = np.loadtxt("lonlat_data/latitude.txt") m = Basemap(llcrnrlon=75, llcrnrlat=15, urcrnrlon=138, urcrnrlat=55, projection="mill", resolution="h") m.drawparallels(np.arange(5.0, 90.0, 10.0), labels=[1, 0, 0, 0]) m.drawmeridians(np.arange(60.0, 181.0, 15.0), labels=[0, 0, 1, 0]) m.readshapefile("shp/CHINA", "CHINA", drawbounds=1, color="black") topo = maskoceans(longitude, latitude, data) im = m.pcolormesh(longitude, latitude, topo, shading="flat", cmap=plt.cm.jet, latlon=True, vmin=1.0e18, vmax=4.0e18) m.drawlsmask(ocean_color="w", lsmask=0) cbar = m.colorbar() cbar.ax.set_ylabel("CO coloumn(molecules $cm^{-2}$)", color="black", fontsize="13", rotation=90) plt.show()
def _prepare_plot(self, resolution="i"): """ Prepare basemap for plotting results of some query :rtype: Basemap :param resolution: Set basemap resolution / area threshold that shall still be displayed (see Basemap documentation for further details) :return: Basemap """ # Determine bounding box if no clipping boundary was supplied if not self.region.bounds or type(self.region.bounds) == str: if isinstance(self, OSMCollection): if hasattr(self, 'Points'): self.region.bounds = self.bbox_of_view(self.Points.results) elif hasattr(self, 'Lines'): self.region.bounds = self.bbox_of_view(self.Lines.results) elif hasattr(self, 'Polygons'): self.region.bounds = self.bbox_of_view( self.Polygons.results) else: self.region.bounds = self.bbox_of_view(self.results) bbox = {'xmin': self.region.bounds[0], 'ymin': self.region.bounds[1], 'xmax': self.region.bounds[2], 'ymax': self.region.bounds[3]} m = Basemap(resolution=resolution, projection='merc', llcrnrlat=bbox['ymin'] - 0.02, urcrnrlat=bbox['ymax'] + 0.02, llcrnrlon=bbox['xmin'] - 0.02, urcrnrlon=bbox['xmax'] + 0.02, lat_ts=(bbox['xmin'] + bbox['xmax']) / 2) m.drawcoastlines() m.drawlsmask(land_color='white', ocean_color='aqua', lakes=True) m.drawcountries() return m
def final_map(lonc, latc, sem1, sem2, rot=0, time=0, tstd=0): # plots the final answer from the iteration on a tight axis around the # epicentral location # additionally adds an error ellipse based on supplied values # Create map (static boundaries match random initial guess bounds) m = Basemap(llcrnrlon=lonc - 3., llcrnrlat=latc - 2., urcrnrlon=lonc + 3., urcrnrlat=latc + 2., resolution='l') # map cosmetics m.drawstates() m.drawcountries() m.drawcoastlines() m.drawlsmask(land_color='coral', ocean_color='aqua', grid=1.25) el = Ellipse((lonc, latc), sem1, sem2, rot, facecolor='b', zorder=10, alpha=0.4) plt.gca().add_patch(el) xcurr, ycurr = m(lonc, latc) m.scatter(xcurr, ycurr, marker='D', color='b') if (time * tstd) != 0: mylabel = r"t = {:.2f} $\pm$ {:.2f}s".format(time, tstd) plt.annotate(mylabel, xy=(xcurr, ycurr), xycoords='data', xytext=(-100., -15.), textcoords='offset points', color='k')
def plot_sites_on_map(coordinate_dict, problem_sites): m = Basemap(projection='merc',llcrnrlat=40,urcrnrlat=50,\ llcrnrlon=-129,urcrnrlon=-118,resolution='i') # Draw the coastlines m.drawcoastlines() # Color the continents # Bug in drawcoastlines does not allow points mapped above land. We use drawlsmask instead. m.drawlsmask(land_color='0.8', ocean_color='w') # draw parallels and meridians. m.drawparallels(np.arange(-90., 91., 2.), labels=[1, 0, 0, 0], fontsize=10) m.drawmeridians(np.arange(-180., 181., 2.), labels=[0, 0, 0, 1], fontsize=10) plt.title("GPS sites") # Transform long and lat to the map projection # Each lat and long value in the maps above are 'mapped' to specific pixels that make up the image # The mapping, defined by the projection used, needs to also be done on the data set. lon = [] lat = [] prob_lon = [] prob_lat = [] for key in coordinate_dict.keys(): mod_lon = (360. - float(coordinate_dict[key]['lng'])) * -1. mod_lat = coordinate_dict[key]['lat'] lon.append(mod_lon) lat.append(mod_lat) if key in problem_sites: prob_lon.append(mod_lon) prob_lat.append(mod_lat) x, y = m(lon, lat) px, py = m(prob_lon, prob_lat) # Now you can use the plt.scatter method to plot your data! plt.scatter(x, y, s=20) plt.scatter(px, py, s=20, color='red') filename = 'figures/gps_map.png' plt.savefig(filename) plt.show()
def plot_diff_map(lons, lats, y_true=None, y_predict=None, y_diff=None, timestamp=None, s=None, cmap=None, outdir='/home/ubuntu/dataset/output/'): """ Plots the difference between the actual and predicted values on a map. """ timestamp = str(int(timestamp)) yr = timestamp[:4] mn = int(timestamp[4:6]) dt = timestamp[6:] months_lst = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] title = months_lst[mn]+' '+dt+', '+yr if cmap is None: cmap=mpl.cm.get_cmap('seismic') norm = mpl.colors.Normalize(vmin=-1.5,vmax=1.5) area_thresh=2500 land_color='grey' ocean_color='lightblue' fig = plt.figure(figsize=(9,7)) plt.title(title, fontsize=18, fontweight='bold', loc='center') plt.axis('off') m = Basemap(projection='merc', llcrnrlat=lats.min(), llcrnrlon=lons.min(), urcrnrlat=lats.max(), urcrnrlon=lons.max(), resolution='f', area_thresh=area_thresh) xi, yi = m(lons, lats) if y_diff is None: y_diff = y_predict-y_true m.scatter(xi, yi, c=y_diff, edgecolor='none', cmap=cmap, s=s, norm=norm) m.drawlsmask(land_color=land_color, ocean_color=ocean_color, lakes=True) plt.tight_layout() img_path = outdir+str(int(timestamp))+'.png' plt.savefig(img_path, bbox_inches='tight', dpi=300) return img_path
plt.title('filled continent background') # as above, but use land-sea mask image as map background. fig = plt.figure() bmap.drawmapboundary() bmap.drawmeridians(np.arange(0,360,30)) bmap.drawparallels(np.arange(-90,90,30)) # plot filled circles at the locations of the cities. bmap.plot(xc,yc,'wo') # plot the names of five cities. for name,xpt,ypt in zip(cities,xc,yc): plt.text(xpt+50000,ypt+50000,name,fontsize=9,color='w') # contour data over the map. cs = bmap.contour(x,y,wave+mean,15,linewidths=1.5) plt.title('land-sea mask background') bmap.drawlsmask(ocean_color='aqua',land_color='coral') # as above, but use blue marble image as map background. fig = plt.figure() bmap.drawmapboundary() bmap.drawmeridians(np.arange(0,360,30)) bmap.drawparallels(np.arange(-90,90,30)) # plot filled circles at the locations of the cities. bmap.plot(xc,yc,'wo') # plot the names of five cities. for name,xpt,ypt in zip(cities,xc,yc): plt.text(xpt+50000,ypt+50000,name,fontsize=9,color='w') # contour data over the map. cs = bmap.contour(x,y,wave+mean,15,linewidths=1.5) plt.title('blue marble background') bmap.bluemarble()
def plotSpatial(argv): fig, axes = plt.subplots(nrows=int(len(argv['models'])), ncols=1, figsize=(8, 16), dpi=100, sharex=True, sharey=True) axes = axes.flatten() for i, model in enumerate(argv['models']): fpath = '../data/annual/%s-avg.nc' % model dataset = Dataset(fpath, mode='r') LONS = dataset.variables['long'][:] LATS = dataset.variables['lat'][:] var = dataset.variables[argv['variableNames'][i]] lon_0 = LONS.mean() lat_0 = LATS.mean() ax = axes[i] ax.set_title(model + ': ' + argv['label'] + ' (' + var.units + ')') # fig.subplots_adjust(left=.1, right=.9, top=.9, bottom=.1) m = Basemap(projection='kav7', lat_0=lat_0, lon_0=lon_0, ax=ax) m.drawlsmask(land_color='#EFEFEF', ocean_color="#FFFFFF") m.drawparallels(np.arange(-90., 91., 30.), labels=[1, 0, 0, 0], fontsize=12, linewidth=.2) m.drawmeridians(np.arange(-180., 181., 40.), labels=[0, 0, 0, 1], fontsize=8, linewidth=.2) m.drawcoastlines(linewidth=.2) lon, lat = np.meshgrid(LONS, LATS) xi, yi = m(lon, lat) # # 以下生成的网格坐标范围为 long: [-180, 180] lat: [-90, 90],与此处的nc不符 # ny = data.shape[0] # nx = data.shape[1] # LONS, LATS = m.makegrid(nx, ny) # x, y = m(LONS, LATS) cmap = LinearSegmentedColormap.from_list('custom_cb', [ (0, '#B8B8B8'), (0.125, '#615EFE'), (0.25, '#0080AC'), (0.375, '#01B251'), (0.5, '#73C605'), (0.675, '#DEF103'), (0.75, '#FF9703'), (0.875, '#FC0101'), (1, '#B30404'), ], N=125) masked = maskoceans(lon, lat, var[:]) # data = np.ma.masked_equal(masked, 0) cs = m.contourf(xi, yi, masked, argv['clevs'][i], cmap=cmap, extend='both') cbar = m.colorbar(cs, location='right', pad='5%') # label='kgC m-2 y-1' cbar.ax.tick_params(labelsize=12) dataset.close() fig.tight_layout() fig.subplots_adjust(bottom=.1, hspace=0.2) # [left, bottom, width, height] # cbar_ax=fig.add_axes([.1, .05, .8, .015]) # cbar = fig.colorbar(cs, cax=cbar_ax, orientation='horizontal') # cbar.set_label('kgC m-2 y-1') plt.savefig('../figure/%s.jpg' % argv['label']) plt.close('all') print(argv['label'] + ' spatial map')
from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt # setup Lambert Conformal basemap. # set resolution=None to skip processing of boundary datasets. m = Basemap(width=12000000,height=9000000,projection='lcc', resolution=None,lat_1=45.,lat_2=55,lat_0=50,lon_0=-107.) # draw a land-sea mask for a map background. # lakes=True means plot inland lakes with ocean color. m.drawlsmask(land_color='coral',ocean_color='aqua',lakes=True) plt.show() plt.show()
lims['ukraine'] = [ 19.0, 42.0, 43.0, 54.0] lims['mediterranean'] = [ -70.0, 5.0, 75.0, 55.0] lims['world'] = [-180.0,-60.0, 180.0, 80.0] lims['nscamerica'] = [-180.0,-60.0, -30.0, 80.0] lims['usa_con'] = [-175.0, 24.0, -40.0, 72.0] lims['usa_main'] = [-130.0, 23.0, -62.0, 50.0] lm = lims[crop_region] m = Basemap(projection='merc', lat_0 = 0, lon_0 = 0, lat_ts=20., resolution = resolution, area_thresh = 0.1, llcrnrlon=lm[0], llcrnrlat=lm[1], urcrnrlon=lm[2], urcrnrlat=lm[3]) # Map options #m.bluemarble() #Use images for backgound. Hard to see routes m.drawlsmask() #Nice grey outlines #m.drawcoastlines(linewidth=0.2) #Unfortunately, has lakes too m.drawcountries() #plt.show() #Just to test out wrap_count=0 line_count=0 if filename.endswith(".gz"): file = gzip.open(filename) elif filename.endswith(".bz2"): file = bz2.BZ2File(filename) else: file = open(filename)
round=True) m.drawmapboundary(fill_color='white') m.drawcoastlines(color='k', linewidth=0.1) parallels = np.arange(50, 90, 10) meridians = np.arange(-180, 180, 30) m.drawparallels(parallels, labels=[True, True, True, True], linewidth=0.2, color='k', fontsize=5) m.drawmeridians(meridians, labels=[True, True, True, True], linewidth=0.2, color='k', fontsize=5) m.drawlsmask(land_color='darkgrey', ocean_color='w') ### Adjust maximum limits values = np.arange(-0.2, 0.21, 0.01) ### Plot filled contours cs = m.contourf(lons[:, :], lats[:, :], val[:, :], values, latlon=True, extend='both') cs1 = m.contour(lons[:, :], lats[:, :], val[:, :], values,
def plot_variable(file_list,variable2plot): map = Basemap(projection='merc',llcrnrlat=44.,urcrnrlat=58.447,\ llcrnrlon=-10.,urcrnrlon=18.,resolution='l') #Paris: lat = 48.5 - 52, lon = 1 - 4.5 #59 , -10 #44 , 18 # draw coastlines, country boundaries, fill continents. map.drawcoastlines(linewidth=0.6, color = 'black') map.drawcountries(linewidth = 0.6, color = 'black') map.drawlsmask(land_color='white',ocean_color='white') # draw lat/lon grid lines every x degrees. map.drawparallels(np.arange( -90.,90.,1.),linewidth=0.1,color = 'Black',labels=[1,0,0,0]) map.drawmeridians(np.arange(-180.,180.,1.),linewidth=0.1,color = 'Black',labels=[0,0,0,1]) cmap = cm.get_cmap(name='rainbow') #NO2: 'rainbow' clouds: 'Blues_r' cmap.set_under('white') #cmap.set_under('0.3') #cmap.set_over('1.0') data_range = None dynamic_range = False if data_range is None: data_range = [1e20, -1e20] dynamic_range = True filters = [ 'cloud_radiance_fraction_nitrogendioxide_window < 0.5', 'surface_albedo < 0.3', 'air_mass_factor_troposphere > 0.2' ] data = [] for f in file_list: var,latb,lonb,extended_name, unit = get_data(f,variable2plot,filters) xtrack_range = None if dynamic_range: try: sel_data = var.data[np.logical_not(var.mask)] if sel_data.shape[0] == 0: print 'continue in the loop' except AttributeError: sel_data = var data_range[0] = min(np.nanmin(sel_data), data_range[0]) data_range[1] = max(np.nanmax(sel_data), data_range[1]) data.append((var, latb, lonb)) for var, latb, lonb in data: x,y = map(lonb,latb) if xtrack_range is None: cs = map.pcolor(x,y,var,cmap=cmap,latlon=False,vmin=0, vmax=20e15) #-10e15, vmax=20e15 else: # pcolormesh cs = map.pcolor(x[:,:], y[:,:], var[:,:], cmap=cmap, latlon=False, vmin=data_range[0], vmax=data_range[1]) cbar = map.colorbar(cs,location='right',pad="12%", extend="both") cbar.set_label(unit) # Label for the plot label = 'TROPOMI o00569 - 11-22-2017' #if label is None: # plt.title(extended_name) #else: #plt.title("{0} - {1}".format(extended_name,label)) # Name of the file for figure fig = 'paris_1122_tropomi' if fig is None: plt.show() else: f = plt.gcf() f.set_size_inches(10.0, 6.0, forward=True) plt.savefig(fig, dpi=300) plt.show()
def worldmap(grid_data=None, boxlat=None, boxlon=None, label=None, scatter=False, ax=None, df=None, dfkey=None, vmin=0, vmax=1000, nb=50.0, sb=22.0, wb=-130.0, eb=-60.0, maskocean=True, colorbar=True, return_cs=False): m = Basemap( projection='merc', resolution='l', # get these from conusdata llcrnrlon=wb, # lower right cornet lat llcrnrlat=sb, urcrnrlon=eb, # upper right corner urcrnrlat=nb, ax=ax) # latitude of the true scale # draw coastlines, state and country boundaries, edge of map. m.drawcoastlines() m.drawstates() m.drawcountries() parallels = np.arange(-50., 50, 10.) m.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10) meridians = np.arange(-180., 180., 20.) m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10) maplat, maplon = np.meshgrid(boxlat, boxlon) x, y = m(maplon, maplat) # compute map proj coordinates. np.shape(y) if maskocean: newdata = maskoceans(maplon, maplat, grid_data) else: newdata = grid_data cs = m.pcolormesh(x, y, newdata, cmap='jet', vmin=vmin, vmax=vmax, norm=mpl.colors.LogNorm()) if not scatter: if colorbar: cbar = m.colorbar(cs, location='bottom', pad="8%", norm=mpl.colors.LogNorm()) cbar.set_label(label) if scatter: sc = m.scatter(df['LON'].values, df['LAT'].values, marker='o', c=df[dfkey].values, s=5, zorder=10, latlon=True, cmap='jet', vmin=vmin, vmax=vmax) if colorbar: cbar2 = m.colorbar(sc, location='bottom', pad="8%") cbar2.set_label(label) m.drawlsmask(land_color=(0, 0, 0, 0), ocean_color='w', lakes=True) if return_cs: return m, cs else: return m
if args.it: inf=float(it[i]) else: inf=0. if args.st: sup=float(st[i]) else: sup=ma.max(var) m = Basemap(llcrnrlat=min(lat),urcrnrlat=max(lat),\ llcrnrlon=min(lon),urcrnrlon=max(lon), resolution='f') x,y=np.meshgrid(lon, lat) m.drawparallels(np.linspace(min(lat), max(lat), 7),labels=[0,0,0,0]) m.drawmeridians(np.linspace(min(lon), max(lon), 7),labels=[0,0,0,0]) if res=='f': m.drawlsmask(land_color=RGB.hex_format(RGB(169,169,169)),ocean_color=RGB.hex_format(RGB(169,169,169)),resolution='f',lakes=True, grid=1.25) #same colour for land and ocean for (r,i) in zip(borders, range(len(borders))): #plot the borders and fill the continent if the polygon is inside poly_NAD #if inf['NAM']!='UNK': #if r.intersects(poly_NAD): elements=list(r.exterior.coords) xx,yy=zip(*elements) xy = zip(xx,yy) poly = Polygon( xy ) if poly.intersects(poly_NAD)==True: m.plot(xx,yy,marker=None, color='black', linewidth=0.5) poly = matplotlib.patches.Polygon( xy, facecolor=RGB.hex_format(RGB(238, 213, 183)) ) plt.gca().add_patch(poly) else: m.drawlsmask(land_color=RGB.hex_format(RGB(238, 213, 183)),ocean_color=RGB.hex_format(RGB(169,169,169)),resolution='f',lakes=True, grid=1.25) m.drawcoastlines()
lon_0 = float(raw_input('enter reference longitude (lon_0):')) lat_0 = float(raw_input('enter reference latitude (lat_0):')) # map with land/sea mask plotted fig = plt.figure() resolution = 'l' grid = 5 m = Basemap(projection='ortho', lon_0=lon_0, lat_0=lat_0, resolution=resolution) # land coral, oceans aqua. # lakes=True means plot inland lakes with ocean color. # resolution = 5 (default) means use 5 min dataset (can use 2.5) m.drawcoastlines() m.drawlsmask(land_color='coral',ocean_color='aqua', lakes=True,\ resolution=resolution,grid=grid) # draw parallels and meridians. m.drawparallels(np.arange(-90., 120., 30.)) m.drawmeridians(np.arange(0., 420., 60.)) m.drawmapboundary() plt.title('Orthographic Map Centered on Lon=%s, Lat=%s' % (lon_0, lat_0)) # map with continents drawn and filled (continent filling fails for # lon=-120,lat=60). fig = plt.figure() m = Basemap(projection='ortho', lon_0=lon_0, lat_0=lat_0, resolution=resolution) m.drawcoastlines() m.fillcontinents(color='coral', lake_color='aqua')
lons, data = m.shiftdata(lon, datain=temp[0, :, :], lon_0=None) x, y = m(lons, lat) Z = maskoceans(lons, lat, data, inlands=True, resolution='c', grid=2.5) #clevs=[-50,-40,-20,-10,0,5,10,15,20,25,30,35,40,45] ; cmap=plt.get_cmap('hot_r') clevs = [0, 5, 10, 15, 25, 30, 35, 40] #nice_cmap= plt.get_cmap('RdYlBu') #colors = nice_cmap([0,8, 16, 40, 60, 80,100,120,140]) #colors = nice_cmap([0,10,20,40,60,80,100,130,160]) #levels = [0, 5, 10, 15, 25,30,35,40] ; #cmap, norm = from_levels_and_colors(levels, colors, extend='both') #cs=m.pcolormesh(x,y,data, cmap=cmap, norm=norm) cs = (m.contourf(x, y, data, clevs, cmap=plt.cm.RdYlBu)) #m.warpimage(image='venuscyl4.jpg') #(m.readshapefile('ncfiles/subdiv/India_subdiv','ind',drawbounds=True, zorder=None, linewidth=1.0, color='k', antialiased=1, ax=None, default_encoding='utf-8')) (m.drawlsmask(land_color='grey', ocean_color='white', lakes=False)) m.fillcontinents(color='white', lake_color='white') (m.drawparallels(np.arange(-90, 90., 45.), labels=[1, 0, 0, 0])) (m.drawmeridians(np.arange(-180., 180., 60.), labels=[0, 0, 0, 1])) (m.drawmapboundary(fill_color='white')) (m.drawcoastlines(linewidth=0.25)) (m.drawcountries(linewidth=0.25)) (m.drawstates(linewidth=0.25)) cbar = (m.colorbar(cs, location='right', pad='5%')) (cbar.set_label('degC')) # m.shaderelief() #m.arcgisimage(service='ESRI_Imagery_World_2D', xpixels = 1500, verbose= True) (plt.title('Sea Surface Temperature(degC)')) savefig('sst_globe.png', dpi=100) plt.show() """ rainfall """
y, varsst, np.arange(-3, 3.01, 0.25), extend='both', alpha=1, zorder=1) cs3 = m.contour(x, y, varsicmean, np.arange(15, 30, 15), alpha=1, linewidths=2, colors='gold', zorder=3) m.drawlsmask(land_color='dimgrey', ocean_color='k') m.drawcoastlines(color='k', linewidth=0.1, zorder=6) m.fillcontinents(color='dimgrey', lake_color='dimgrey', zorder=5) parallels = np.arange(50, 86, 5) meridians = np.arange(-180, 180, 30) m.drawparallels(parallels, labels=[False, False, False, False], linewidth=0.0, color='w') par = m.drawmeridians(meridians, labels=[True, True, False, False], linewidth=0.0, fontsize=4, color='w') setcolor(par, 'darkgrey')
llcrnrlat=22, urcrnrlon=-60, # upper right corner urcrnrlat=52, lat_ts=35) # latitude of the true scale # draw coastlines, state and country boundaries, edge of map. m.drawcoastlines() m.drawstates() m.drawcountries() parallels = np.arange(0., 90, 10.) m.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10) meridians = np.arange(180., 360., 10.) m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10) maprlon, maprlat = np.meshgrid(rlon, rlat) xr, yr = m(maprlon, maprlat) # compute map proj coordinates. cs = m.contourf(xr, yr, Band1) m.drawlsmask(land_color=(0, 0, 0, 0), ocean_color='w', lakes=True) sc = m.scatter(dfs['LON'].values, dfs['LAT'].values, marker='o', c='red', s=1, zorder=10, latlon=True) cbar = m.colorbar(cs, location='bottom', pad="8%") cbar.set_label('Elevation [m MSL]') plt.title('Elevation', fontsize=12) plt.savefig(os.path.join(cfun.outplot, 'Original_elevation.png'), dpi=100) plt.show() data = mean_el
""" ##Plot data plt.figure(figsize=(16,10)) plt.tight_layout() m = Basemap(projection='merc',llcrnrlat=y1m.min(),urcrnrlat=y1m.max(),\ llcrnrlon=x1m.min(),urcrnrlon=x1m.max(),lat_ts=20,resolution='l', area_thresh=0) #m = Basemap(projection='merc',llcrnrlat=bminlat,urcrnrlat=bmaxlat,\ #llcrnrlon=bminlon,urcrnrlon=bmaxlon,lat_ts=20,resolution='l', area_thresh=0) m.drawparallels(np.arange(-80., 81., 3.), labels=[1, 0, 0, 0], fontsize=15) m.drawmeridians(np.arange(-180., 181., 3.), labels=[0, 0, 0, 1], fontsize=15) # Add Bermuda outline m.drawcoastlines() m.fillcontinents() m.drawlsmask(land_color='grey',ocean_color='white',lakes=True) x1_mask, y1_mask = m(x1m, y1m) x11, y11 = m(x1, y1) #plt.contourf(x1_mask, y1_mask,bz_c, cmap = 'Blues') #plt.contourf(x1_mask, y1_mask,bz_a, cmap = 'Reds') #plt.contourf(x11, y11,nz_c, cmap = 'Blues') plt.contourf(x11, y11,nz_a, cmap = 'Reds') plt.colorbar(label='Eddy concentration (mean counts/year)', orientation='vertical') plt.title('Frequency of eddies in the Bermuda region \n from ROMS model') plt.savefig(image_path + 'eddy_freq_Bermuda_NWAT_anticyclonic.png', bbox_inches = 'tight') #Plot anomaly (sigma) sigma = (bz_a/5 + bz_c/5) - nz_a - nz_c a_sigma = bz_a/5 - nz_a c_sigma = bz_c/5 - nz_c plt.figure(figsize=(16,10))
### Call parameters plt.rcParams['text.usetex']=True plt.rcParams['font.family'] = 'sans-serif' plt.rcParams['font.sans-serif'] = 'Avant Garde' yearnew = np.arange(2003,2010,1) ### Define figure fig = plt.figure() for i in xrange(len(thickness)): ax = plt.subplot(2,4,i+1) m = Basemap(projection='npstere',boundinglat=60,lon_0=-90,resolution='l',round=True) m.drawmapboundary(fill_color = 'white') m.drawcoastlines(color = 'darkgrey',linewidth=0.2) m.drawlsmask(land_color='darkgrey',ocean_color='snow') parallels = np.arange(50,90,10) meridians = np.arange(-180,180,30) m.drawparallels(parallels,labels=[False,False,False,False],linewidth=0.25) m.drawmeridians(meridians,labels=[False,False,False,False],linewidth=0.25) cs = m.contourf(lon,lat,thickness3[i,:,:],np.arange(-3,3.1,0.25), latlon=True,extend='both') cs.set_cmap('seismic_r') ax.text(0.89,0.95,r'\textbf{%s}' % (yearnew[i]),size='9', horizontalalignment='center',backgroundcolor='w', verticalalignment='center',bbox=dict(facecolor='w', edgecolor='k',alpha=0.9),transform=ax.transAxes) plt.tight_layout() fig.subplots_adjust(bottom=0.13)
def draw_kmeans_clusters(self, filename, figsize=(4, 3)): import matplotlib as mpl mpl.use('Agg') import matplotlib.patches as mpatches import matplotlib.pyplot as plt from sklearn.cluster import KMeans from scipy.spatial import Voronoi, voronoi_plot_2d from mpl_toolkits.basemap import Basemap, cm, maskoceans #from matplotlib import style #import seaborn as sns #sns.set_style("white") #plt.rc('text', usetex=True) #plt.rc('font', family='serif') #plt.rcParams['axes.facecolor']='white' fig = plt.figure(figsize=figsize) lllat = 24.396308 lllon = -124.848974 urlat = 49.384358 urlon = -66.885444 m = Basemap(llcrnrlat=lllat, urcrnrlat=urlat, llcrnrlon=lllon, urcrnrlon=urlon, resolution='c', projection='cyl') m.drawmapboundary(fill_color='white') m.drawcoastlines(linewidth=0.2) m.drawcountries(linewidth=0.2) ax = plt.gca() ax.xaxis.set_visible(False) ax.yaxis.set_visible(False) for spine in ax.spines.itervalues(): spine.set_visible(False) #fig = plt.figure() # figsize=(4,4.2) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.spines['left'].set_visible(False) train_locs = self.df_train[['lat', 'lon']].values n_clusters = int(np.ceil(train_locs.shape[0] / self.bucket_size)) n_clusters = 128 logging.info('n_cluster %d' % n_clusters) clusterer = KMeans(n_clusters=n_clusters, n_jobs=10) clusterer.fit(train_locs) centroids = clusterer.cluster_centers_ centroids[:, [0, 1]] = centroids[:, [1, 0]] mlon, mlat = m(*(centroids[:, 0], centroids[:, 1])) centroids = np.transpose(np.vstack((mlon, mlat))) vor = Voronoi(centroids) #ax.set_xlim([-125, -60]) # pylab.xlim([-400, 400]) #ax.set_ylim([25, 50]) plt.setp(ax.get_yticklabels(), visible=False) plt.setp(ax.get_xticklabels(), visible=False) ax.yaxis.set_tick_params(size=0) ax.xaxis.set_tick_params(size=0) #plt.tick_params(axis='both', which='major', labelsize=25) #ax.labelsize = '25' #plt.subplots_adjust(bottom=0.2) voronoi_plot_2d(vor, show_points=False, show_vertices=False, ax=ax, line_width=0.7) m.drawlsmask(land_color='lightgray', ocean_color="#b0c4de", lakes=True) plt.tight_layout() plt.savefig(filename) #plt.close() print("the plot saved in " + filename)
def draw_map(map_type, geo_dict, filename, headless, leg_choice): import matplotlib as mpl if headless: mpl.use("Agg") import matplotlib.pyplot as plt from mpl_toolkits.basemap import Basemap # ## Map stuff ## plt.figure(figsize=(16, 9), dpi=100, frameon=False) lon_r = 0 lon_l = 0 if map_type == 'NA': m = Basemap(llcrnrlon=-119, llcrnrlat=22, urcrnrlon=-54, urcrnrlat=55, projection='lcc', resolution='l', lat_1=32, lat_2=45, lon_0=-95) lon_r = 66.0 lon_l = -124.0 elif map_type == 'EU': m = Basemap(llcrnrlon=-15., llcrnrlat=20, urcrnrlon=75., urcrnrlat=70, projection='lcc', resolution='l', lat_1=30, lat_2=60, lon_0=35.) lon_r = 50.83 lon_l = -69.03 elif map_type == 'World': m = Basemap(projection='robin', lat_0=0, lon_0=-100, resolution='l', area_thresh=100000.0) # m.drawmeridians(np.arange(0, 360, 30)) # m.drawparallels(np.arange(-90, 90, 30)) lon_r = 180 lon_l = -180.0 # remove line in legend mpl.rcParams['legend.handlelength'] = 0 m.drawmapboundary(fill_color='#1F1F1F') m.drawcoastlines() m.drawstates() m.drawcountries() m.drawlsmask(land_color='#3C3C3C', ocean_color='#1F1F1F') for key, values in geo_dict.items(): # add Accuracy as plot/marker size, change play count to del_s value. for data in values: if key == SERVER_FRIENDLY: color = '#FFAC05' marker = '*' markersize = 10 zord = 3 alph = 1 else: if data['platform'] in PLATFORM_COLORS: color = PLATFORM_COLORS[data['platform']] else: color = DEFAULT_COLOR print( 'Platform: {} is missing from PLATFORM_COLORS. Using DEFAULT_COLOR.' .format(data['platform'])) marker = '.' if data['play_count'] >= 100: markersize = (data['play_count'] * .1) elif data['play_count'] <= 2: markersize = 2 else: markersize = 2 zord = 2 alph = 0.4 px, py = m(float(data['lon']), float(data['lat'])) x, y = m( [float(data['lon']), float(SERVER_LON)], [float(data['lat']), float(SERVER_LAT)]) legend = 'Location: {}, {}, User: {}\nPlatform: {}, IP: {}, Play Count: {}'.format( data['city'], data['region'], key, data['platform'], data['ip'], data['play_count']) # Keeping lines inside the Location. Plots outside Location will still be in legend if float(data['lon']) != float(SERVER_LON) and float(data['lat']) != float(SERVER_LAT) and \ lon_l < float(data['lon']) < lon_r: # Drawing lines from Server location to client location if data['location_count'] > 1: lines = m.plot(x, y, marker=marker, color=color, markersize=0, label=legend, alpha=.6, zorder=zord, linewidth=2) # Adding dash sequence to 2nd, 3rd, etc lines from same city,state for line in lines: line.set_solid_capstyle('round') dashes = [ x * data['location_count'] for x in [5, 8, 5, 8] ] line.set_dashes(dashes) else: m.plot(x, y, marker=marker, color=color, markersize=0, label=legend, alpha=.4, zorder=zord, linewidth=2) m.plot(px, py, marker=marker, color=color, markersize=markersize, label=legend, alpha=alph, zorder=zord) if leg_choice: handles, labels = plt.gca().get_legend_handles_labels() idx = labels.index( 'Location: {}, {}, User: {}\nPlatform: {}, IP: {}, Play Count: {}' .format(SERVER_CITY, SERVER_STATE, SERVER_FRIENDLY, SERVER_PLATFORM, REPLACEMENT_WAN_IP, 0)) labels = labels[idx:] + labels[:idx] handles = handles[idx:] + handles[:idx] by_label = OrderedDict(list(zip(labels, handles))) leg = plt.legend(list(by_label.values()), list(by_label.keys()), fancybox=True, fontsize='x-small', numpoints=1, title="Legend", labelspacing=1., borderpad=1.5, handletextpad=2.) if leg: lleng = len(leg.legendHandles) for i in range(1, lleng): leg.legendHandles[i]._legmarker.set_markersize(10) leg.legendHandles[i]._legmarker.set_alpha(1) leg.get_title().set_color('#7B777C') leg.set_draggable(state=True) leg.get_frame().set_facecolor('#2C2C2C') for text in leg.get_texts(): plt.setp(text, color='#A5A5A7') plt.title(title_string) if filename: plt.savefig('{}.png'.format(filename)) print('Image saved as: {}.png'.format(filename)) if not headless: mng = plt.get_current_fig_manager() mng.window.state('zoomed') plt.show()
if cat == '123': self.c_123_x.append(x) self.c_123_y.append(y) if cat == '45': self.c_45_x.append(x) self.c_45_y.append(y) nc_path = r"P:\01_DataOriginals\GOM\Metocean\StormData\Year.2005.ibtracs_wmo.v03r10.nc" m = Basemap(llcrnrlon=-98., llcrnrlat=17., urcrnrlon=-80., urcrnrlat=31., \ projection='lcc', lat_0=30., lon_0=-90., \ resolution='l', area_thresh=1000.) # draw coastlines and meridians m.drawcoastlines() m.drawlsmask(land_color='#827d7c', ocean_color='#8dcef9', lakes=True) m.drawparallels(np.arange(10, 70, 5), labels=[1, 1, 0, 0]) m.drawmeridians(np.arange(-100, 0, 5), labels=[0, 0, 0, 1]) # first open and get all the names of the storms with Dataset(nc_path, 'r') as ds: basin = ds.variables['basin'] lon = ds.variables['lon_wmo'] lat = ds.variables['lat_wmo'] wind = ds.variables['wind_wmo'] dsLen = len(ds.variables['basin']) # loop through each storm for i in range(0, dsLen): print('storm ' + format(i))
plt.rc('font',**{'family':'sans-serif','sans-serif':['Avant Garde']}) fig = plt.figure() ax = plt.subplot(221) m = Basemap(projection='npstere',boundinglat=66,lon_0=270, resolution='l',round =True) m.drawmapboundary(fill_color='white') m.drawcoastlines(color='k',linewidth=0.2) parallels = np.arange(50,90,10) meridians = np.arange(-180,180,30) #m.drawparallels(parallels,labels=[False,False,False,False], # linewidth=0.3,color='k',fontsize=6) #m.drawmeridians(meridians,labels=[False,False,False,False], # linewidth=0.3,color='k',fontsize=6) m.drawlsmask(land_color='darkgrey',ocean_color='mintcream') # Make the plot continuous barlim = np.arange(-1,1.1,.5) values = np.arange(-1,1.1,0.1) cs = m.contourf(lons,lats,corr_w, values,latlon=True) cs1 = m.contour(lons,lats,corr_w, values,linewidths=0.2,colors='darkgrey', linestyles='-',latlon=True) cs.set_cmap('RdBu_r') ax.annotate(r'\textbf{JFM}', xy=(0, 0), xytext=(-0.23, 0.9), xycoords='axes fraction',fontsize=22,color='darkgrey')
m = Basemap(projection='cyl', llcrnrlon=sys.argv[2], \ urcrnrlon=sys.argv[3], llcrnrlat=sys.argv[4],urcrnrlat=sys.argv[5], \ lat_ts=20, resolution='i') # add wrap-around point in longitude. prmsl, lons = addcyclic(prmsl, lons) # contour levels clevs = np.arange(900, 1100., 5.) # find x,y of map projection grid. lons, lats = np.meshgrid(lons, lats) x, y = m(lons, lats) # create figure. fig = plt.figure(figsize=(8, 4.5)) ax = fig.add_axes([0.05, 0.05, 0.9, 0.85]) cs = m.contour(x, y, prmsl, clevs, colors='k', linewidths=1.) m.drawcoastlines(linewidth=1.25) m.drawlsmask(land_color=(0.25, 0.5, 0, 1), ocean_color=(0.9, 0.9, 1, 1)) m.fillcontinents(color=(0.25, 0.5, 0, 1)) # m.drawparallels(np.arange(-80,81,20),labels=[1,1,0,0]) # m.drawmeridians(np.arange(0,360,60),labels=[0,0,0,1]) xlows = x[local_min] xhighs = x[local_max] ylows = y[local_min] yhighs = y[local_max] lowvals = prmsl[local_min] highvals = prmsl[local_max] # plot lows as blue L's, with min pressure value underneath. xyplotted = [] # don't plot if there is already a L or H within dmin meters.
# **it's easy to make this fail with global aeqd plots. # For example, if the center point is at the North Pole, # the continent filling routines get confused and fills # the outside of Antartica instead of the inside** #m.drawmapboundary(fill_color='white') #m.drawcoastlines(linewidth=0.5) #m.fillcontinents(color='black',lake_color='white') #m.drawparallels(np.arange(-80,81,20),color='0.7') #m.drawmeridians(np.arange(-180,180,20),color='0.7') # draw lsmask instead of drawing continents (slower, but more robust). m.drawlsmask(land_color='black', ocean_color='white', lakes=True, resolution='l', grid=5) m.drawparallels(np.arange(-80, 81, 20), color='0.7') m.drawmeridians(np.arange(-180, 180, 20), color='0.7') m.drawmapboundary() # blue marble background (pretty, but slow). #m.bluemarble(scale=0.5) #m.drawparallels(np.arange(-80,81,20),color='0.5') #m.drawmeridians(np.arange(-180,180,20),color='0.5') #m.drawmapboundary(color='0.5') # draw a red dot at the center. xpt, ypt = m(lon_0, lat_0)
import numpy as np df= pd.read_csv(io.BytesIO(uploaded['q3dbscan.csv'])) print(df.shape) df.dropna(subset=['Lat','Long'],inplace=True) df print("Lat max",df['Lat'].max()) print("Lat min",df['Lat'].min()) print("Long max",df['Long'].max()) print("Long min",df['Long'].min()) my_map = Basemap(projection='merc',resolution='l',area_thresh=1000,llcrnrlat=25.753,llcrnrlon=-152,urcrnrlat=57.79,urcrnrlon=-7.539) my_map.drawstates() my_map.drawlsmask(land_color='orange',ocean_color='skyblue') my_map.bluemarble() my_map.etopo() my_map.drawstates() my_map.drawlsmask(land_color='orange',ocean_color='skyblue') my_map.bluemarble() my_map.etopo() xs,ys=my_map(np.asarray(df.Long),np.asarray(df.Lat)) df['xm']= xs.tolist() df['ym'] =ys.tolist() df_cluster=df[["Long","Lat"]] df_cluster=StandardScaler().fit_transform(df_cluster) x = np.array(df_cluster)
def show_clouds_ortho(self, time, centre, map_bkgd='bluemarble', out='show'): """ Show an orthographic projection with cloud cover that ranges from transparent for small cloud fraction, to white to grey. args: time - time_utils.Time instance that the cloud field will get interpolated to and shown for. centre - tuple of (lat, lon), indicating the centre of the orthographic projection map_bkgd - string to indicate what kind of back- ground will be used for the image. Can be any of 'bluemarble', 'etopo', or 'mask' out - string to indicate what kind of output should be provided """ if type(time) == type(dt.datetime(2015, 4, 4)): time = time_utils.Time(time, time) def col(x): """ Function that provides RGBA values for a given cloud fraction between 0 and 1. """ # get RGB value c = 1. - 0.3*x**2. # transparent if c.f. < 0.1 if x < 0.1: return (c,c,c,0) # opaque if c.f. > 0.7 elif x > 0.7: return (c,c,c,1.) # translucent if 0.1 < c.f. < 0.7 else: return (c,c,c,np.clip((x - 0.1)/0.7, 0., 1.)**2.) # draw map projection projection = Basemap(projection='ortho', lat_0=centre[0], lon_0=centre[1], resolution='c') # determine what kind of background # is needed, and draw it if map_bkgd == 'bluemarble': projection.bluemarble() elif map_bkgd == 'etopo': projection.etopo() elif map_bkgd == 'mask': projection.drawlsmask(land_color='limegreen', ocean_color='dodgerblue', resolution='l') projection.drawcoastlines(linewidth=0.75) projection.drawcountries(linewidth=0.5) projection.drawmeridians(np.arange(-180, 181, 30), latmax=90) projection.drawparallels(np.arange(-90, 91, 15), latmax=90) else: raise ValueError('invalid map background specification') # use a call to interpolate the cloud # fields to the needed time cf = self(time) # define MERRA lat and lon grid lats = np.arange(-90., 90.25, 0.5) lons = np.arange(-180., 180.3125, 0.625) lons, lats = np.meshgrid(lons, lats) # define contour levels and colors levs = np.linspace(0,1,256, endpoint=True) clevs = [col(x) for x in levs] # get the map projection coordinates # and mask the cloud data, so that lcoations # on the opposite side of th Earth don't get # drawn x, y = projection(lons, lats) cfmask = np.ma.masked_greater(x, 1e15).mask cfmasked = np.ma.array(cf, mask=cfmask) # draw contour plt.contourf(x, y, cfmasked, levs, colors=clevs, extend='both') # supply specified output if out == 'show': plt.show() elif out == '': pass else: plt.savefig(out) return cfmask
### Define figure if style == 'ortho': m = Basemap(projection='ortho',lon_0=-90, lat_0=70,resolution='l',round=True) elif style == 'polar': m = Basemap(projection='npstere',boundinglat=67,lon_0=270,resolution='l',round =True) for i in range(aug.shape[0]): fig = plt.figure() ax = plt.subplot(111) for txt in fig.texts: txt.set_visible(False) var = sit[i,:,:] m.drawmapboundary(fill_color='k') m.drawlsmask(land_color='k',ocean_color='k') m.drawcoastlines(color='mediumseagreen',linewidth=0.4) # Make the plot continuous barlim = np.arange(0,9,1) # cmap = colormapSIT() cmap = colormapSIT() cs = m.contourf(lons,lats,var, np.arange(0,7.1,0.25),extend='max', alpha=1,latlon=True,cmap=cmap) if i >= 38: ccc = 'mediumseagreen' else: ccc = 'w'
boundinglat=-50, round=True, lon_0=180) #----------------------------------------- lon, lat = np.meshgrid(lons, lats) xi, yi = m(lon, lat) levels = np.linspace(-100, 100, 14, endpoint=True, dtype=int) ax = fig.add_subplot(421) ax.set_title('a) GDFL-CM3', fontsize=18) sic = m.contourf(xi, yi, sic, shading='interp', cmap=plt.cm.seismic, levels=levels) m.drawlsmask() m.drawcoastlines() m.drawparallels(np.arange(-80., 81., 20.)) m.drawmeridians(np.arange(-180., 181., 20.)) #----------------------------------------- sic = '/home/leticia/Documentos/2020.1/leticia_dados_CMIP/dados_subtraidos/GDFL_dif_cmip6.nc' fh = Dataset(sic, mode='r') lons = fh.variables['lon'][:] lats = fh.variables['lat'][:] #sic = fh.variables['sic'][2,:,:] #sic = fh.variables['icec'][9,:,:] sic = fh.variables['siconc'][9, :, :] sic_units = fh.variables['siconc'].units fh.close() lon_0 = lons.mean() lat_0 = lats.mean()
def plotUH(self, report, date, gsystem, ctype, filepath): """Plot horenzital and vertical errors. Arg: report:report of coor file, type:pandas.dataframe. date:coor file date. gsystem:GNSS system. ctype:calculate type. filepath:result path. """ # connect to station database, returieve station b, l connect = sqlite3.connect( os.path.join(os.path.dirname(__file__), 'station.sqlite')) cur = connect.cursor() latitude = list() longtitude = list() index = list() for i, name in enumerate(report.name): cur.execute('SELECT B, L FROM Station WHERE name=?', (name.lower(), )) try: cur_fetch = cur.fetchone() latitude.append(cur_fetch[0]) longtitude.append(cur_fetch[1]) index.append(i) except: continue cur.close() connect.close() if not latitude: return # start plot # set colorbar range if ctype == 'DFPPP': colorbar_vmax = 1 elif ctype == 'SFPPP': colorbar_vmax = 3 elif ctype == 'SFSPP': colorbar_vmax = 10 fig = plt.figure(figsize=(20, 10)) grid = ImageGrid(fig, 111, nrows_ncols=(1, 2), axes_pad=0.2, share_all=True, cbar_mode='single', cbar_size="5%", cbar_pad=0.1) for ax, i in zip(grid, [0, 1]): if i == 0: color = [report.H_95.values[i] for i in index] mean = sum(color) / len(color) title = 'Horizontal Errors [mean:%.3f]' % mean else: color = [report.U_95.values[i] for i in index] mean = sum(color) / len(color) title = 'Vertical Errors [mean:%.3f]' % mean ax.set_title(title, size=22, weight='bold') m = Basemap(projection='cyl', llcrnrlat=9, urcrnrlat=61, llcrnrlon=70, urcrnrlon=140, ax=ax) m.drawcountries(color='#778899') m.drawlsmask(land_color='#F0E68C', ocean_color='#87CEEB', lakes=False) if i == 0: m.drawparallels(np.arange(10, 70, 10), labels=[1, 0, 0, 0], linewidth=0.01, fontsize=18, weight='bold') m.drawmeridians(np.arange(75, 140, 10), labels=[0, 0, 0, 1], linewidth=0.01, fontsize=18, weight='bold') mscatter = m.scatter(longtitude, latitude, latlon=True, c=color, s=200, marker='o', cmap=cm.get_cmap('jet'), vmin=0, vmax=colorbar_vmax, alpha=0.95) cbar = ax.cax.colorbar(mscatter) cbar.ax.set_title('m', size=18, weight='bold') plt.setp(cbar.ax.yaxis.get_ticklabels(), size=18, weight='bold') title = { 'BDS': 'BDS', 'GPS': 'GPS', 'GBS': 'BDS/GPS', 'MIX': 'GPS+BDS+GLO+GAL' } fig.suptitle('%s %s %s' % (title[gsystem], ctype, str(date)), y=0.84, size=24, weight='bold') fig_name = '-'.join([ctype, gsystem, str(date), 'HV']) fig_path = os.path.join(filepath, str(date), '-'.join([ctype, gsystem])) if not os.path.exists(fig_path): os.makedirs(fig_path) plt.savefig(os.path.join(fig_path, ''.join([fig_name, '.png'])), bbox_inches='tight') # add station name for ax in grid: for name, lon, lat in zip(report.name.tolist(), longtitude, latitude): x, y = m(lon, lat) ax.text(x, y, name, size=12, weight='bold') plt.savefig(os.path.join(fig_path, ''.join([fig_name, '_name.png'])), bbox_inches='tight') plt.clf() plt.close()