def show_ws(groups, size): plt.close('all') fig = plt.figure(figsize = (size, size)) ax = fig.add_subplot(111) m = Basemap(projection = 'cyl', resolution = 'l', area_thresh = 10000, llcrnrlat = lat0, urcrnrlat = lat1, llcrnrlon = lon0, urcrnrlon = lon1) m.drawcoastlines() m.drawcountries() m.drawparallels(np.arange(lat0, lat1, 10), labels=[1,1,0,0]) m.drawmeridians(np.arange(lon0, lon1, 10), labels=[0,0,0,1]) this_mask = np.zeros((int((lat1 - lat0) / acc_res), int((lon1 - lon0) / acc_res)), dtype = 'uint8') for this_group in groups: this_rand = int(np.random.uniform(1, 255)) for this_odr in this_group: mask = df_ws.loc[this_odr, 'mask'] latlon = df_ws.loc[this_odr, 'latlon'] y0 = int(round((lat1 - latlon[0]) / acc_res)) y1 = y0 + mask.shape[0] x0 = int(round((latlon[1] - lon0) / acc_res)) x1 = x0 + mask.shape[1] this_mask[y0:y1, x0:x1] = this_mask[y0:y1, x0:x1] + mask * this_rand this_mask = np.where(this_mask == 0, np.nan, this_mask) m.imshow(this_mask, origin = 'upper', interpolation = 'nearest', zorder = 10, alpha = 1) plt.show()
def plot_data(data,lon_data, lat_data, periodname, AODcatname,maptype,cmapname,minv=0,maxv=0,folder=""): fig = plt.figure() #ax = fig.add_axes([0.1,0.1,0.8,0.8]) m = Basemap(llcrnrlon=19,llcrnrlat=34,urcrnrlon=29,urcrnrlat=42, resolution='h',projection='cass',lon_0=24,lat_0=38) nx = int((m.xmax-m.xmin)/1000.)+1 ny = int((m.ymax-m.ymin)/1000.)+1 topodat = m.transform_scalar(data,lon_data,lat_data,nx,ny) if minv<>0 or maxv<>0 : im = m.imshow(topodat,cmap=plt.get_cmap(cmapname),vmin=minv,vmax=maxv) else: im = m.imshow(topodat,cmap=plt.get_cmap(cmapname)) m.drawcoastlines() m.drawmapboundary() m.drawcountries() m.drawparallels(np.arange(35,42.,1.), labels=[1,0,0,1]) m.drawmeridians(np.arange(-20.,29.,1.), labels=[1,0,0,1]) cb = m.colorbar(im,"right", size="5%", pad='2%') title=maptype+" AOD "+AODcatname+" "+periodname+" 2007-2014" plt.title(title) pylab.savefig(folder+maptype+"AOD"+AODcatname+"_"+periodname + ".png")
def plot_2Ddata_with_underlay(data_array, lons=None, lats=None): """ Plot of a 2D array on top of coast lines and country lines. """ figure() # Create the basemap instance and draw the continents # Basemap kw args: llcrnrlon = lower left corner longitude, and so on m = Basemap(llcrnrlon=-180, llcrnrlat=-90, urcrnrlon=180, urcrnrlat=90, projection="mill") m.drawcoastlines(linewidth=1.25) m.drawcountries(linewidth=0.5) # m.fillcontinents(color='0.8') m.drawparallels(np.arange(-90, 91, 20), labels=[1, 1, 0, 0]) m.drawmeridians(np.arange(-180, 180, 60), labels=[0, 0, 0, 1]) # Shift the data by 180 in longitude to center the map on longitude=0 data_array, lon_out = shiftgrid(180, data_array, lons) # Add the data, and place origin in upper left since the origin of the numpy # array corresponds tolat = 90 and long = 0 m.imshow(data_array, origin="upper") # More complex version that involves interpolation on a grid of points in # map coordinates. # nx = int((m.xmax-m.xmin)/500.)+1; ny = int((m.ymax-m.ymin)/500.)+1 # dat_array = m.transform_scalar(data_array, lons,lats,nx,ny) # m.imshow(dat_array, origin = 'upper') # figure() # m = Basemap(projection='ortho',lon_0=-105,lat_0=40) # m.drawcoastlines(linewidth=1.25) # m.drawcountries(linewidth=0.5) # dat_transformed = m.transform_scalar(data_array, return
def __init__(self, subPlot = None, gpxData = None): GeoSectionViewerGpxData.__init__(self, subPlot, gpxData) latitudes, longitudes, elevations, timestamps = self.gpxData.getLatLongElevTs() latitudeMax = max(latitudes) latitudeMin = min(latitudes) longitudeMax = max(longitudes) longitudeMin = min(longitudes) elevationMax = max(elevations) elevationMin = min(elevations) scalledMax = 30 scalledMin = 1 scalledElevations = [((((point.elevation - elevationMin) * (scalledMax - scalledMin)) / (elevationMax - elevationMin)) + scalledMin) for i, point in enumerate(self.gpxData)] bbox = longitudeMin, latitudeMin, longitudeMax, latitudeMax mm = geotiler.Map(extent=bbox, zoom=14) img = geotiler.render_map(mm) img.save("geotiler.png") map = Basemap( llcrnrlon=bbox[0], llcrnrlat=bbox[1], urcrnrlon=bbox[2], urcrnrlat=bbox[3], projection='merc', resolution='i', ax=self.subPlot) map.imshow(img, aspect='auto', origin='upper') map.scatter(longitudes, latitudes, c='red', s=scalledElevations, marker='o', cmap=cm.hot_r, alpha=0.4, latlon=True) map.plot(longitudes, latitudes, 'k', c='red', latlon=True)
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 background_map(self, ax): llcrnrlat, urcrnrlat, llcrnrlon, urcrnrlon, lat_ts = (31, 44, -126, -113, 37.5) m = Basemap(projection='merc', llcrnrlat=llcrnrlat, urcrnrlat=urcrnrlat, llcrnrlon=llcrnrlon, urcrnrlon=urcrnrlon, lat_ts=lat_ts, resolution='i', ax=ax) m.drawmapboundary(fill_color='lightblue', zorder=0) m.fillcontinents(zorder=0) etopofn = '/home/behry/uni/data/etopo1_central_europe_gmt.grd' etopodata = Dataset(etopofn, 'r') z = etopodata.variables['z'][:] x_range = etopodata.variables['x_range'][:] y_range = etopodata.variables['y_range'][:] spc = etopodata.variables['spacing'][:] lats = np.arange(y_range[0], y_range[1], spc[1]) lons = np.arange(x_range[0], x_range[1], spc[0]) topoin = z.reshape(lats.size, lons.size, order='C') # transform to nx x ny regularly spaced 5km native projection grid nx = int((m.xmax - m.xmin) / 5000.) + 1; ny = int((m.ymax - m.ymin) / 5000.) + 1 topodat, x, y = m.transform_scalar(np.flipud(topoin), lons, lats, nx, ny, returnxy=True) ls = LightSource(azdeg=300, altdeg=15, hsv_min_sat=0.2, hsv_max_sat=0.3, hsv_min_val=0.2, hsv_max_val=0.3) # shade data, creating an rgb array. rgb = ls.shade(np.ma.masked_less(topodat / 1000.0, 0.0), cm.gist_gray_r) m.imshow(rgb) m.drawmeridians(np.arange(6, 12, 2), labels=[0, 0, 0, 1], color='white', linewidth=0.5, zorder=0) m.drawparallels(np.arange(44, 50, 2), labels=[1, 0, 0, 0], color='white', linewidth=0.5, zorder=0) m.drawcoastlines(zorder=1) m.drawcountries(linewidth=1.5, zorder=1) m.drawstates() m.drawrivers(color='lightblue', zorder=1) return m
def plot_world_sst(): # Read some NetCDF data import netCDF4 as nc ostia = nc.Dataset('ostia.nc') tmp = ostia.variables['analysed_sst'][0] ice = ostia.variables['sea_ice_fraction'][0] lon = ostia.variables['lon'][:] lat = ostia.variables['lat'][:] from mpl_toolkits.basemap import Basemap # Set up a map map = Basemap(projection='cyl') map.drawcoastlines() map.drawcountries() map.fillcontinents(color='lightgreen', lake_color='lightblue'); map.drawmapboundary(fill_color='lightblue') # Re-project the data onto the map image = map.transform_scalar(tmp,lon,lat,200,200) # Plot the data map.imshow(image); plt.show()
def mk_regmap_contour(a2in, bnd, scm, stitle, soname, cbarname, miss_out): #------------------------ # Basemap #------------------------ print "Basemap" figmap = plt.figure() axmap = figmap.add_axes([0.1, 0.0, 0.8, 1.0]) M = Basemap( resolution="l", llcrnrlat=lllat, llcrnrlon=lllon, urcrnrlat=urlat, urcrnrlon=urlon, ax=axmap) #-- transform ----------- print "transform" a2value_trans = M.transform_scalar( a2in, a1lon, a1lat, nnx, nny) a2value_trans = a2value_trans.filled(miss_out) #-- to contour ---------- a2value_trans = dtanl_fsub.mk_a2contour_regional(a2value_trans.T, 0.0, 0.0, -9999.0).T #-- boundaries ---------- bnd_cbar = [-1.0e+40] + bnd + [1.0e+40] #-- color --------------- cminst = matplotlib.cm.get_cmap(scm, len(bnd)) acm = cminst( arange( len(bnd) ) ) lcm = [[1,1,1,1]]+ acm.tolist() mycm = matplotlib.colors.ListedColormap( lcm ) #-- imshow ----------- im = M.imshow(a2value_trans, origin="lower", norm=BoundaryNormSymm(bnd), cmap=mycm, interpolation="nearest") #-- shade ----------- a2shade_trans = ma.masked_not_equal(a2value_trans, miss_out) cmshade = matplotlib.colors.ListedColormap([(0.8,0.8,0.8), (0.8,0.8,0.8)]) im = M.imshow(a2shade_trans, origin="lower", cmap=cmshade) #-- coastline --------------- print "coastlines" M.drawcoastlines() #-- meridians and parallels M.drawmeridians(arange(0.0,360.0, meridians), labels=[0, 0, 0, 1]) M.drawparallels(arange(-90.0,90.0, parallels), labels=[1, 0, 0, 0]) #-- title ------------------- axmap.set_title("%s"%(stitle)) #-- save -------------------- plt.savefig(soname) print soname # for colorbar --- if cbarflag == "True": figmap = plt.figure() axmap = figmap.add_axes([0.1, 0.0, 0.8, 1.0]) M = Basemap( resolution="l", llcrnrlat=lllat, llcrnrlon=lllon, urcrnrlat=urlat, urcrnrlon=urlon, ax=axmap) a2v_trans = M.transform_scalar( a2in, a1lon, a1lat, nnx, nny) im = M.imshow(a2value_trans, origin="lower", norm=BoundaryNormSymm(bnd), cmap=mycm) figcbar = plt.figure(figsize=(5, 0.6)) axcbar = figcbar.add_axes([0, 0.4, 1.0, 0.6]) bnd_cbar = [-1.0e+40] + bnd + [1.0e+40] plt.colorbar(im, boundaries= bnd_cbar, extend="both", cax=axcbar, orientation="horizontal") figcbar.savefig(cbarname)
def main(): ncols = 841 nrows = 681 ndays = 366 f = open("modis_climatology_splined.bin", "r") data = np.fromfile(f).reshape((ndays,nrows,ncols)) f.close() ncolours = 7 vmin = 0 vmax = 6 cmap = sns.blend_palette(["white", "#1b7837"], ncolours, as_cmap=True) sns.set(style="white") fig = plt.figure(figsize=(10, 6)) grid = AxesGrid(fig, [0.05,0.05,0.9,0.9], nrows_ncols=(1,1), axes_pad=0.1, cbar_mode='single', cbar_pad=0.4, cbar_size="7%", cbar_location='bottom', share_all=True) # 111.975 + (841. * 0.05) # -44.025 + (681. * 0.05) m = Basemap(projection='cyl', llcrnrlon=111.975, llcrnrlat=-44.025, \ urcrnrlon=154.025, urcrnrlat=-9.974999999999994, resolution='h') ax = grid[0] m.ax = ax shp_info = m.readshapefile('/Users/mdekauwe/research/Drought_linkage/' 'Bios2_SWC_1979_2013/' 'AUS_shape/STE11aAust', 'STE11aAust', drawbounds=True) #m.drawrivers(linewidth=0.5, color='k') ax.set_xlim(140.5, 154) ax.set_ylim(-38, -28) #cmap = cmap_discretize(plt.cm.YlGnBu, ncolours) m.imshow(data[20,:,:], cmap, colors.Normalize(vmin=vmin, vmax=vmax, clip=True), origin='upper', interpolation='nearest') cbar = colorbar_index(cax=grid.cbar_axes[0], ncolours=ncolours, cmap=cmap, orientation='horizontal', vmin=vmin, vmax=vmax) fig.savefig("/Users/mdekauwe/Desktop/LAI_NSW.png", bbox_inches='tight', pad_inches=0.1, dpi=300) plt.show()
def radagast_test(): lower_left, upper_right = corner_coords() m = Basemap(projection='geos', lon_0=0, resolution='i', llcrnrlon=lower_left[0], llcrnrlat=lower_left[1], urcrnrlon=upper_right[0], urcrnrlat=upper_right[1]) m.drawcoastlines() im = Image.open('TEST-radagast.jpg') m.imshow(im) plt.show()
class CoordinateAnimation: def __init__(self, corners, zoom, data_pipe, figsize=(16, 9), scatter_params={}): self.corners = corners self.zoom = zoom self.scatter_params = scatter_params self.data_pipe = data_pipe self.plot_data = np.zeros(shape=(1, 2)) self.fig, self.ax = plt.figure(figsize=figsize), plt.subplot(111) self._init_basemap() self.anim_scatter = animation.FuncAnimation(self.fig, self._update_scatter, init_func=self._scatter_init) self.plot_scat = None self.plot_plot = None def _init_basemap(self): self.m = geotiler.Map(extent=self.corners, zoom=self.zoom) self.img = geotiler.render_map(self.m) self.bmap = Basemap( llcrnrlon=self.corners[0], llcrnrlat=self.corners[1], urcrnrlon=self.corners[2], urcrnrlat=self.corners[3], projection="merc", ax=self.ax ) self.bmap.imshow(self.img, interpolation='lanczos', origin='upper') def _scatter_init(self): self.plot_scat = plt.scatter(self.plot_data[:, 0], self.plot_data[:, 1], **self.scatter_params) self.plot_plot = plt.plot(self.plot_data[:, 0], self.plot_data[:, 1]) def _update_scatter(self, i): try: if not self.data_pipe.poll(3): return self.plot_scat, except KeyboardInterrupt: return self.plot_scat, try: gps_json = self.data_pipe.recv() except KeyboardInterrupt: return self.plot_scat, gga = gps_json['gga'] try: parsed = pynmea2.parse(gga) except pynmea2.nmea.ChecksumError: return self.plot_scat, array = np.array(self.bmap(parsed.longitude, parsed.latitude)) self.plot_data = np.vstack( (self.plot_data, array) ) self.plot_scat.set_offsets(array) plt.plot(self.plot_data[1:, 0], self.plot_data[1:, 1]) return self.plot_scat, def plot(self): plt.show()
def make_map(llcrnrlon, urcrnrlon, llcrnrlat, urcrnrlat, image): fig, ax = plt.subplots() m = Basemap(llcrnrlon=llcrnrlon, urcrnrlon=urcrnrlon, llcrnrlat=llcrnrlat, urcrnrlat=urcrnrlat, resolution='c', projection='merc', lon_0=(urcrnrlon + llcrnrlon) / 2, lat_0=(urcrnrlat + llcrnrlat) / 2, lat_ts=-23.5) m.ax = ax m.imshow(plt.imread(image), origin='upper', zorder=1) return fig, ax, m
def makeFigs(): m = Basemap(llcrnrlon=-9.382918,llcrnrlat=39.119533,urcrnrlon= -9.376521,urcrnrlat= 39.127501, resolution='l',projection='merc') x1,y1=m(x,y) xarray.append(x1) yarray.append(y1) m.drawcoastlines() im = plt.imread("map.png") m.imshow(im, origin='upper') m.scatter(xarray,yarray,c='b',marker=".",alpha=1.0)
def PlotTomoMap(fname, dlon=0.5, dlat=0.5, title='', datatype='ph', outfname='', browseflag=False, saveflag=True): """ Plot Tomography Map longitude latidute ZValue """ if title=='': title=fname; if outfname=='': outfname=fname; Inarray=np.loadtxt(fname) LonLst=Inarray[:,0] LatLst=Inarray[:,1] ZValue=Inarray[:,2] llcrnrlon=LonLst.min() llcrnrlat=LatLst.min() urcrnrlon=LonLst.max() urcrnrlat=LatLst.max() Nlon=int((urcrnrlon-llcrnrlon)/dlon)+1 Nlat=int((urcrnrlat-llcrnrlat)/dlat)+1 fig=plt.figure(num=None, figsize=(8, 12), dpi=80, facecolor='w', edgecolor='k') m = Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon, urcrnrlat=urcrnrlat, \ rsphere=(6378137.00,6356752.3142), resolution='l', projection='merc') lon = LonLst lat = LatLst x,y = m(lon, lat) xi = np.linspace(x.min(), x.max(), Nlon) yi = np.linspace(y.min(), y.max(), Nlat) xi, yi = np.meshgrid(xi, yi) #-- Interpolating at the points in xi, yi zi = griddata(x, y, ZValue, xi, yi) # m.pcolormesh(xi, yi, zi, cmap='seismic_r', shading='gouraud') cmap=matplotlib.cm.seismic_r cmap.set_bad('w',1.) m.imshow(zi, cmap=cmap) m.drawcoastlines() m.colorbar(location='bottom',size='2%') # m.fillcontinents() # draw parallels m.drawparallels(np.arange(-90,90,10),labels=[1,1,0,1]) # draw meridians m.drawmeridians(np.arange(-180,180,10),labels=[1,1,1,0]) plt.suptitle(title,y=0.9, fontsize=22); if browseflag==True: plt.draw() plt.pause(1) # <------- raw_input("<Hit Enter To Close>") plt.close('all') if saveflag==True: fig.savefig(outfname+'.ps', format='ps') return
def plot_file(filename): # Open the file using the NetCDF4 library nc = Dataset(filename) # analyze_dataset(nc) latlon = nc.variables['geospatial_lat_lon_extent'] # print('geospatial_lat_lon_extent:', latlon) # Original example uses Brightness Temperature values, 'CMI' # But that's not in our dataset. whichvar = 'Rad' data = nc.variables[whichvar][:] prettyname = nc.variables[whichvar].long_name # Show it without basemap: # plt.imshow(data, cmap='Greys') # plt.show() # Create the basemap reference for the Satellite Projection bmap = Basemap(projection='geos', # Extents llcrnrlon=latlon.geospatial_westbound_longitude, llcrnrlat=latlon.geospatial_southbound_latitude, urcrnrlon=latlon.geospatial_eastbound_longitude, urcrnrlat=latlon.geospatial_northbound_latitude, # Should these be nadir, or center? lon_0=latlon.geospatial_lon_nadir, lat_0=latlon.geospatial_lat_nadir, satellite_height=35786023.0, ellps='GRS80') # Plot GOES-16 Channel using 170 and 378 as the temperature thresholds bmap.imshow(data, origin='upper', cmap='Greys') # Draw the coastlines, countries, parallels and meridians bmap.drawcoastlines(linewidth=0.3, linestyle='solid', color='blue') bmap.drawcountries(linewidth=0.3, linestyle='solid', color='blue') # These don't seem to do anything bmap.drawparallels(np.arange(-90.0, 90.0, 10.0), linewidth=0.1, color='yellow') bmap.drawmeridians(np.arange(0.0, 360.0, 10.0), linewidth=0.1, color='yellow') # Insert the legend bmap.colorbar(location='bottom', label=prettyname) # Show the plot plt.show()
def __init__(self, subPlot = None, gpxData = None, geoMarkers = None): GeoSectionViewerGpxData.__init__(self, subPlot, gpxData) latitudes, longitudes, elevations, timestamps = self.gpxData.getLatLongElevTs() latitudeMax = max(latitudes) latitudeMin = min(latitudes) longitudeMax = max(longitudes) longitudeMin = min(longitudes) elevationMax = max(elevations) elevationMin = min(elevations) scalledMax = 30 scalledMin = 1 scalledElevations = [((((point.elevation - elevationMin) * (scalledMax - scalledMin)) / (elevationMax - elevationMin)) + scalledMin) for i, point in enumerate(self.gpxData)] bbox = longitudeMin, latitudeMin, longitudeMax, latitudeMax mm = geotiler.Map(extent=bbox, zoom=14) self.rawMapImage = geotiler.render_map(mm) map = Basemap( llcrnrlon=bbox[0], llcrnrlat=bbox[1], urcrnrlon=bbox[2], urcrnrlat=bbox[3], projection='merc', resolution='i', ax=self.subPlot) map.imshow(self.rawMapImage, aspect='auto', origin='upper') #--draw path map.scatter(longitudes, latitudes, c='red', s=scalledElevations, marker='o', cmap=cm.hot_r, alpha=0.4, latlon=True) map.plot(longitudes, latitudes, 'k', c='red', latlon=True) #--draw labels if(geoMarkers is not None): for geoMarker in geoMarkers: xy = map(geoMarker["longitude"], geoMarker["latitude"]) # # subPlot.annotate( # geoMarker["name"], # xy, xytext = (-20, 20), # textcoords = 'offset points', ha = 'right', va = 'bottom', # # bbox = dict(boxstyle = 'round,pad=0.5', fc = 'yellow', alpha = 0.5), # bbox = dict(fc = 'yellow', alpha = 0.5), # arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0')) # subPlot.text(xy[0], xy[1], "{0}-{1} {2}".format(geoMarker["name"], geoMarker["elevation"], geoMarker["time"]),fontsize=9, ha='center',va='top',color='r', # bbox = dict(ec='None',fc=(1,1,1,0.5))) bbox = dict(fc = 'yellow', alpha = 0.5))
def plot_mappa(paese): def GetExtent(gt,cols,rows): ext=[] xarr=[0, cols] yarr=[0, rows] for px in xarr: for py in yarr: x=gt[0]+(px*gt[1])+(py*gt[2]) y=gt[3]+(px*gt[4])+(py*gt[5]) ext.append([x,y]) #print x,y yarr.reverse() return ext pathToRaster = "input_data/geocoded/risk_map/" + paese + ".tif" from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt import numpy as np from osgeo import gdal raster = gdal.Open(pathToRaster, gdal.GA_ReadOnly) array = raster.GetRasterBand(1).ReadAsArray() msk_array = np.ma.masked_equal(array, value=65535) # print 'Raster Projection:\n', raster.GetProjection() geotransform = raster.GetGeoTransform() cols = raster.RasterXSize rows = raster.RasterYSize ext = GetExtent(geotransform, cols, rows) #print ext[1][0], ext[1][1] #print ext[3][0], ext[3][1] #map = Basemap(projection='merc',llcrnrlat=-80, urcrnrlat=80, llcrnrlon=-180,urcrnrlon=180,lat_ts=20,resolution='c') map = Basemap(projection='merc', llcrnrlat=ext[1][1], urcrnrlat=ext[3][1], llcrnrlon=ext[1][0], urcrnrlon=ext[3][0],lat_ts=20, resolution='c') # Add some additional info to the map map.drawcoastlines(linewidth=1.3, color='white') #map.drawrivers(linewidth=.4, color='white') map.drawcountries(linewidth=.75, color='white') #datain = np.flipud(msk_array) datain = np.flipud(msk_array) map.imshow(datain)#,origin='lower',extent=[ext[1][0], ext[3][0],ext[1][1],ext[3][1]]) plt.show() #plot_mappa("India")
def plotField(fileName, vmin, vmax, colormap='goddard', output_folder='/', lonlatbox='-180,180,-90,90'): ''' Plot any field variable :param fileName: filepath :param vmin: min value for colorbar :param vmax: max value for colorbar ''' fig1 = plt.figure(figsize=(12,7),dpi=500) if(colormap == 'goddard'): my_cmap = mpl.colors.LinearSegmentedColormap('my_colormap',Plotter.colorDict2,256) else: my_cmap = plt.cm.RdBu_r file_values = FileHandler.openNetCDFFile(fileName) mVar = file_values['variable'] lon = file_values['lon'] lat = file_values['lat'] if lonlatbox is None: if lon[0] < 0: lonlatbox = '-180,180,-90,90' else: lonlatbox = '0,360,-90,90' lonlatbox = map(int,lonlatbox.split(',')) m = Basemap(llcrnrlon=lonlatbox[0],llcrnrlat=lonlatbox[2],urcrnrlon=lonlatbox[1],urcrnrlat=lonlatbox[3]) def divi(x): return float(x)/10 colorSteps = map(divi,range(int(vmin*10),int((vmax*10)+1),1))#(vmax-vmin)/2)) if vmax == 0.5: colorSteps = [-0.5, -0.45, -0.4, -0.35, -0.3, -0.25, -0.2, -0.15, -0.1, -0.05, 0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5] if vmax == 0. and vmin == -0.5: colorSteps = [-0.5, -0.475, -0.45, -0.425, -0.4, -0.375, -0.35, -0.325, -0.3, -0.275, -0.25, -0.225, -0.2, -0.175, -0.15, -0.125, -0.1, -0.075, -0.05, -0.025, 0] if vmax == 2. and vmin == 0: colorSteps = [0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9,0.95, 1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0] colorTicks = colorSteps[0::2] my_cmap.set_bad("grey") #set missing value color #maskedArray = N.ma.masked_greater(mVar, 0.8e20) #mask missing Values maskedArray = N.ma.masked_outside(mVar, -0.8e20, 0.8e20) #discrete colormap norm = mpl.colors.BoundaryNorm(colorSteps, my_cmap.N) cs = m.imshow(maskedArray, interpolation="nearest", cmap=my_cmap, norm=norm) cb = m.colorbar(cs,"right", size="5%", pad='5%' , ticks=colorTicks) m.drawcoastlines() m.drawparallels(N.arange(-90.,120.,30.),labels=[1,0,0,0]) # draw parallels m.drawmeridians(N.arange(0.,420.,60.),labels=[0,0,0,1]) # draw meridians plt.title(Plotter.__getTitle(fileName)) plt.text(lonlatbox[0]+(lon[1]-lon[0])/2, lonlatbox[2]+(lat[1]-lat[0])/2, 'MurCSS') #print lonlatbox[0]+lon[1]-lon[0] return m
def stere(data,latitude,longitude,filename): """ :param data: CO浓度数据矩阵 :param latitude: 纬度 :param longitude: 经度 :param filename: :return: """ ax = plt.gca() fig = plt.figure() m = Basemap(width=10000000,height=7500000, resolution='l',projection='stere',\ lat_ts=35,lat_0=35,lon_0=107.) nx = int((m.xmax-m.xmin)/5000.)+1 ny = int((m.ymax-m.ymin)/5000.)+1 topodat = m.transform_scalar(data,longitude,latitude,nx,ny) im = m.imshow(topodat,cm.GMT_haxby,vmin=0,vmax=4e18) m.drawcoastlines() m.drawcountries() m.drawparallels(np.arange(-80.,81.,20.),labels=[1,0,0,0]) # 画平行的纬度,前一个参数是表示起点,终点,间距的序列,后一个参数是指在哪一个方向显示纬度、经度值 m.drawmeridians(np.arange(-180.,181.,20.),labels=[0,0,0,1]) # 画平行的经度 m.colorbar(im) plt.title("CO"+filename[12:14]) outname = filename+'.png' fig.savefig(outname, dpi=fig.dpi)
def do_plot(self, dataset): #for dataset in r533: points, plot_type, lons, lats, num_pts_lon, num_pts_lat, params = dataset plot_dt, plot_title, freq, idx = params #plt.figure(figsize=(12,6)) m = Basemap(projection='cyl', resolution='l') m.drawcoastlines(color='black', linewidth=0.75) m.drawcountries(color='grey') m.drawmapboundary(color='black', linewidth=1.0) m.drawmeridians(np.arange(0,360,30)) m.drawparallels(np.arange(-90,90,30)) X,Y = np.meshgrid(lons, lats) #todo remove hard-coded values for vmin and vmax #im = m.pcolormesh(X, Y, points, shading='gouraud', cmap=plt.cm.jet, latlon=True, vmin=-20, vmax=40) #im = m.pcolormesh(X, Y, points, shading='gouraud', cmap=plt.cm.jet, latlon=True, vmin=-20, vmax=40) im = m.imshow(points, interpolation='bilinear', vmin=0, vmax=100) if self.plot_terminator: m.nightshade(plot_dt) cb = m.colorbar(im,"bottom", size="5%", pad="2%") plt.title(plot_title) plot_fn = "area_{:s}_{:s}_{:s}.png".format(plot_type, plot_dt.strftime("%H%M_%b_%Y"), "d".join(str(freq).split('.'))) print ("Saving file ", plot_fn) plt.savefig(plot_fn, dpi=float(self.dpi), bbox_inches='tight')
def plot_ndvi(hdf_fname, fig_name, min_lat, min_lon, max_lat, max_lon, title='NDVI plot'): """Produce a plot of the NDVI data in file `hdf_fname`.""" import matplotlib.pyplot as plt from matplotlib import cm from mpl_toolkits.basemap import Basemap ndvi = read_ndvi(hdf_fname, min_lat, min_lon, max_lat, max_lon) print 'Data obtained' print type(ndvi) fig = plt.figure() ax = fig.add_subplot(111) curr_map = Basemap(projection='cyl', llcrnrlat=min_lat, urcrnrlat=max_lat, llcrnrlon=min_lon, urcrnrlon=max_lon, resolution='l') curr_map.drawcoastlines(linewidth=1.5) curr_map.drawcountries(linewidth=1.5) curr_map.drawparallels(np.arange(-90.,91.,2.), labels=[1, 0, 0, 0]) curr_map.drawmeridians(np.arange(-180.,181.,2.), labels=[1, 0, 0, 1]) im = curr_map.imshow(ndvi, cmap=cm.BrBG, origin='upper', interpolation='nearest') cbar = fig.colorbar(im, ticks=[0, 0.4, 0.8]) cbar.set_label('NDVI') cbar.ax.set_yticklabels(['< 0', '0.4', '> 0.8']) ax.set_title(title, fontsize=16, fontweight='bold') fig.savefig(fig_name)
def plot_hmap_ortho(h, cmap='jet', mode='log', mx=None, drng=None, res=0.25, verbose=False): m = Basemap(projection='ortho',lat_0=90,lon_0=180,rsphere=1.) if verbose: print 'SCHEME:', h.scheme() print 'NSIDE:', h.nside() lons,lats,x,y = m.makegrid(360/res,180/res, returnxy=True) lons = 360 - lons lats *= a.img.deg2rad; lons *= a.img.deg2rad y,x,z = a.coord.radec2eq(n.array([lons.flatten(), lats.flatten()])) ax,ay,az = a.coord.latlong2xyz(n.array([0,0])) data = h[x,y,z] data.shape = lats.shape data /= h[0,0,1] #data = data**2 # only if a voltage beam data = data_mode(data, mode) m.drawmapboundary() m.drawmeridians(n.arange(0, 360, 30)) m.drawparallels(n.arange(0, 90, 10)) if mx is None: mx = data.max() if drng is None: mn = data.min() # if min < (max - 10): min = max-10 else: mn = mx - drng step = (mx - mn) / 10 levels = n.arange(mn-step, mx+step, step) return m.imshow(data, vmax=mx, vmin=mn, cmap=cmap)
def map_vis(data,title=[],vmin=None,vmax=None,barlabel=None,cmap=None,outputdir=None): # print("visualizing : "+title) if cmap==None: cmap=cm.jet if len(data.shape)>2: plotdata=data[0,:,:] else: plotdata=data plt.clf() # plt.figure(figsize=(3,3),dpi=200) ny,nx=plotdata.shape geo=[35,43,-113,-101] if experiment=="conus":geo=[25,52.7,-124.7,-67] m = Basemap(projection='cyl',llcrnrlat=geo[0],urcrnrlat=geo[1],\ llcrnrlon=geo[2],urcrnrlon=geo[3],resolution="i") mapimg=m.imshow(plotdata,vmin=vmin,vmax=vmax,cmap=cmap) if experiment=="conus": m.drawparallels(np.arange(25,55,5.),labels=[1,0,0,0],dashes=[1,4]) m.drawmeridians(np.arange(-120,-65,10.),labels=[0,0,0,1],dashes=[1,4]) m.drawstates(linewidth=0.5) m.drawcountries(linewidth=0.5) m.drawcoastlines(linewidth=0.5) else: m.drawparallels(np.arange(36,43,2.),labels=[1,0,0,0],dashes=[1,4]) m.drawmeridians(np.arange(-112,-103,4.),labels=[0,0,0,1],dashes=[1,4]) m.drawstates(linewidth=1.5) cbar=m.colorbar() if barlabel: cbar.set_label(barlabel) plt.title(" ".join(title)) if outputdir: plt.savefig(outputdir+"_".join(title)+'_map.png') else: plt.savefig("_".join(title)+'_map.png')
def imshow(self, data, low=0, high=255, **kwargs): ''' Make RGB plot over the map data : numpy array RGB or RGBA input data **kwargs: Parameters for Basemap.imshow Modifies --------- self.mpl : list append AxesImage object with imshow ''' # Create X/Y axes self._create_xy_grids() # add random colormap if 'cmap' in kwargs and kwargs['cmap'] == 'random': values = np.unique(data[np.isfinite(data)]) cmap, norm = self._create_random_colormap(values, low=low, high=high) kwargs['cmap'] = cmap kwargs['norm'] = norm # Plot data using imshow self.mpl.append(Basemap.imshow(self, data, extent=[self.x.min(), self.x.max(), self.y.min(), self.y.max()], origin='upper', **kwargs)) self.colorbar = len(self.mpl) - 1
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 satellite_plot(): imgsrc = 'http://lance-modis.eosdis.nasa.gov/imagery/subsets/?subset=ARM_Azores.' \ + iter_date.strftime('%Y%j') \ + '.aqua.2km.jpg' #ENA - Graciosa Island, Azores #39° 5' 29.68" N, 28° 1' 32.34" W #Altitude: 30.48 meters #from shapelib import ShapeFile file = cStringIO.StringIO(urllib.urlopen(imgsrc).read()) try: img = Image.open(file) except IOError: img = None #print(imgsrc) fig, ax = plt.subplots(figsize=(12,12)) ax.set_title(iter_date.strftime('%A %B %d %Y'), y=1.05) m = Basemap(llcrnrlat=28.9951, llcrnrlon=-38.0039, urcrnrlat=48.9990, urcrnrlon=-18.000, resolution='c', ax=ax, area_thresh=0.1) #m.drawcoastlines() m.drawparallels(np.arange(-90, 90, 5), labels=[1,1,1,1]) m.drawmeridians(np.arange(-180, 180, 5), labels=[1,1,1,1]) if img is not None: m.imshow(img, origin='upper') m.plot(-28.02565, 39.091578, 'r*', markersize=20, latlon=True) m.readshapefile(os.path.join(support_directory, 'PRT_adm/PRT_adm0'), 'prt', drawbounds=True) if img is not None: img.close() figout = os.path.join(plot_directory, 'satellite/') if not os.path.isdir(figout): os.makedirs(figout) fig.savefig(os.path.join(figout, iter_date.strftime('%Y-%m-%d')+'.png'), transparent=False)
def map_test(): # image edges for west africa seviri # (measured from the fennec browser hr panner) ll_lat = 2.60 ll_lon = -30.64 ur_lat = 46.31 ur_lon = 44.66 # ul_lat = 47.28 # ul_lon = -54.00 # lr_lat = 2.58 # lr_lon = 27.08 m = Basemap(projection='geos', llcrnrlon=ll_lon, llcrnrlat=ll_lat, urcrnrlon=ur_lon, urcrnrlat=ur_lat, resolution='h') image = Image.open('TEST.png') m.imshow(image) m.drawcountries() return m
def plot_hpx(hpx, mode='log', pol='x', mx=None, drng=2, interpolation=False, colorbar=False, nogrid=False): im = a.img.Img(size=400, res=.4) x,y,z = im.get_top(center=n.array(im.shape)/2) assert(pol in 'xy') hpx.set_interpol(interpolation) if pol == 'x': d = hpx[x,y,z] else: d = hpx[-y,x,z] d.shape = x.shape d = n.where(x.mask, 0, d) if mode.startswith('phs'): d = n.angle(d) elif mode.startswith('lin'): d = n.absolute(d) elif mode.startswith('real'): d = d.real elif mode.startswith('imag'): d = d.imag elif mode.startswith('log'): d = n.absolute(d) d = n.ma.masked_less_equal(d, 0) d = n.ma.log10(d) else: raise ValueError('Unrecognized plot mode.') if mx is None: mx = d.max() if drng is None: drng = mx - d.min() mn = mx - drng if not nogrid: from mpl_toolkits.basemap import Basemap map = Basemap(projection='ortho', lon_0=180, lat_0=90, rsphere=1, llcrnrx=-1.25, llcrnry=-1.25, urcrnrx=1.25,urcrnry=1.25) map.drawmeridians(n.arange(-180,180,30)) map.drawparallels(n.arange(0,90,15)) map.drawmapboundary() map.imshow(d, vmin=mn, vmax=mx, interpolation='nearest') else: p.imshow(d, vmin=mn, vmax=mx, origin='lower', interpolation='nearest') #data.shape = az.shape #m.drawmapboundary() #m.drawmeridians(n.arange(0,360,30)) #m.drawparallels(n.arange(0,90,10)) #step = (max - min) / 35. #levels = n.arange(min-step, max+step, step) #m.contourf(cx, cy, data, levels) if colorbar: p.colorbar(shrink=.5)
def map_plot(self,ax): xmin = self.geodict['xmin'] xmax = self.geodict['xmax'] ymin = self.geodict['ymin'] ymax = self.geodict['ymax'] clat = ymin + (ymax-ymin)/2.0 bmap = Basemap(llcrnrlon=xmin,llcrnrlat=ymin, urcrnrlon=xmax,urcrnrlat=ymax, projection='merc',lat_ts=clat, resolution='h',ax=ax) img = bmap.imshow(flipud(self.griddata)) bmap.drawcoastlines(color='w') return img
lats = np.arange(-60., 60., 0.05)[::-1] lons1, lats1 = np.meshgrid(lons, lats) fig = plt.figure() ax1 = plt.subplot2grid((7, 6), (0, 0), colspan=6, rowspan=3) m1 = Basemap(llcrnrlon=-180.,llcrnrlat=-60.,urcrnrlon=180.,urcrnrlat=60.,\ projection='mill',lon_0=0) m1.drawcountries(linewidth=0.2) m1.drawcoastlines(linewidth=0.3) m1.drawparallels(np.arange(-60., 60., 30.), linewidth=0.05) m1.drawmeridians(np.arange(-180., 180., 60.), linewidth=0.05) cmap = LinearSegmentedColormap.from_list('mycmap', [(0 / 2., 'gray'), (1 / 2., 'black'), (2 / 2., 'white')]) #im1 = m1.pcolormesh(lons1, lats1, merged_map[0,:,:],shading='flat', cmap=cmap, latlon=True) im1 = m1.imshow(np.flipud(merged_map[0, :, :]), cmap=cmap) ax1.set_ylabel('Merged MODIS image', fontsize=10) cb1 = m1.colorbar(im1, 'right', pad='1%', ticks=[0, 1, 2], boundaries=[0, 0.1, 1.9, 2]) cb1.ax.set_yticklabels(['Ground', 'Cloud', 'Snow'], size='x-small') title1 = ax1.set_title('Day: ' + t0.strftime('%Y-%m-%d')) ax2 = plt.subplot2grid((7, 6), (3, 0), colspan=6, rowspan=3) m2 = Basemap(llcrnrlon=-180.,llcrnrlat=-60.,urcrnrlon=180.,urcrnrlat=60.,\ projection='mill',lon_0=0) m2.drawcountries(linewidth=0.2) m2.drawcoastlines(linewidth=0.3) m2.drawparallels(np.arange(-60., 60., 30.), linewidth=0.05) m2.drawmeridians(np.arange(-180., 180., 60.), linewidth=0.05)
m = Basemap(projection='cyl', llcrnrlat=rlat_0, urcrnrlat=rlat_1, llcrnrlon=rlon_0, urcrnrlon=rlon_1, resolution='c') m.drawcoastlines() m.drawparallels( np.arange(-10, 60, 20), labels=[1, 0, 0, 0], fontsize=9) #labels=[left,right,top,bottom] #horizontal line m.drawmeridians( np.arange(80, 180, 20), labels=[0, 0, 0, 1], fontsize=9) #labels=[left,right,top,bottom] #vertical line m.imshow(array, cmap=cmap, vmin=0, vmax=100) #draw figure plt.title(fn_name, fontsize=9) cbar = m.colorbar( size="5%", pad=0.05, extend='max') #pad=distance, extend='colorbar shape,,' cbar.ax.tick_params(labelsize=8) #labelsize=colorbar font size cbar.set_label('Rainfall intensity(mm/hr)', fontsize=8, ha='center') #ha='label text position' #------------------ ''' n=n+1 #---PE FILE SUBPLOT--- plt.subplot(6,2,n) #subplot(y,x,position)
m = Basemap(projection='ortho', lat_0=19, lon_0=-166, resolution='i') #m = Basemap(llcrnrlon=lonmin,llcrnrlat=latmin,urcrnrlon=lonmax,urcrnrlat=latmax#, # resolution='i',projection='merc',lon_0=27.,lat_0=46.7) clip_path = m.drawmapboundary() #m.contour(x,y,layer,cmap=RGB_light,linewidth=0,rasterized=True) tmp = np.loadtxt( '/raid1/sc845/Tomographic_models/SEMUCB_WM1/UCB_a3d_dist.SEMUCB-WM1.r20151019/SEMUCB_WM1_2800km.dat' ) lon = tmp[:, 1].reshape((181, 361)) lat = tmp[:, 2].reshape((181, 361)) dvs = tmp[:, 3].reshape((181, 361)) s = m.transform_scalar(dvs, lon[0, :], lat[:, 0], 1000, 500) im = m.imshow(s, cmap=plt.cm.seismic_r, clip_path=clip_path, vmin=-3, vmax=0) cb = plt.colorbar() cb.set_label('dlnVs (%)') cb.set_clim(-15, 15) cb.remove() x, y = m(lon, lat) lon, lat, layer = LMC.get_slice(piercedepth, whattoplot='votesslow') x, y = m(lon.ravel(), lat.ravel()) x = x.reshape(np.shape(layer)) y = y.reshape(np.shape(layer)) minval = np.min(np.min(layer)) maxval = np.max(np.max(layer)) + .1 #m.shadedrelief() m.drawcoastlines()
def plot_MWAconstellations(outfile=None, obsinfo=None, viewgps=None, observing=True, showbeam=True, constellations=True, gleamsources=False, notext=False, inverse=False, skydata=None, background=None, hidenulls=False, channel=None, # Frequency channel to use for the beam map, defaults to mean of all channels in obs. xmas=XMAS, plotscale=SCALE, # A scale of 1.0 gives a 1200x1200 pixel plot logger=DEFAULTLOGGER): if obsinfo is None: logger.error('Unable to find observation info') return None if skydata is None: skydata = SkyData() if not skydata.valid: logger.error('Unable to load star/planet data, aborting.') return None if background is None: background = 'transparent' if channel is None: if 0 in obsinfo['rfstreams']: channel = obsinfo['rfstreams'][0]['frequencies'][12] elif '0' in obsinfo['rfstreams']: channel = obsinfo['rfstreams']['0']['frequencies'][12] s_obstime = su.time2tai(obsinfo['starttime']) a_obstime = Time(obsinfo['starttime'], format='gps', scale='utc') if viewgps is None: s_viewtime = s_obstime a_viewtime = a_obstime else: s_viewtime = su.time2tai(viewgps) a_viewtime = Time(viewgps, format='gps', scale='utc') a_viewtime.delta_ut1_utc = 0 # We don't care about IERS tables and high precision answers LST_hours = a_viewtime.sidereal_time(kind='apparent', longitude=config.MWAPOS.lon) observer = su.S_MWAPOS.at(s_viewtime) mapzenith = SkyCoord(ra=skydata.skymapRA, dec=skydata.skymapDec, equinox='J2000', unit=(astropy.units.deg, astropy.units.deg)) mapzenith.location = config.MWAPOS mapzenith.obstime = a_viewtime altaz = mapzenith.transform_to('altaz') Az, Alt = altaz.az.deg, altaz.alt.deg fig = plt.figure(figsize=(FIGSIZE * plotscale, FIGSIZE * plotscale), dpi=DPI) ax1 = fig.add_subplot(1, 1, 1) bmap = Basemap(projection='ortho', lat_0=su.MWA_TOPO.latitude.degrees, lon_0=LST_hours.hour * 15 - 360, ax=ax1) nx = len(skydata.skymapra) ny = len(skydata.skymapdec) ax1.cla() # show the Haslam map tform_skymap = bmap.transform_scalar(skydata.basemap[0].data[0][:, ::-1], skydata.skymapra[::-1] * 15, skydata.skymapdec, nx, ny, masked=True) if inverse: cmap = CMI else: cmap = CM bmap.imshow(numpy.ma.log10(tform_skymap[:, ::-1]), cmap=cmap, vmin=math.log10(LOW), vmax=math.log10(HIGH)) delays = [] if showbeam: if not hidenulls: contours = [0.001, 0.1, 0.5, 0.90] if observing: beamcolor = ((0.0, 0.0, 0.0), (0.0, 0.5, 0.0), (0.0, 0.75, 0.0), (0.0, 1.0, 0.0)) else: beamcolor = ((0.0, 0.0, 0.0), (0.5, 0.5, 0.5), (0.75, 0.75, 0.75), (1.0, 1.0, 1.0)) else: contours = [0.1, 0.5, 0.90] if observing: beamcolor = ((0.0, 0.5, 0.0), (0.0, 0.75, 0.0), (0.0, 1.0, 0.0)) else: beamcolor = ((0.5, 0.5, 0.5), (0.75, 0.75, 0.75), (1.0, 1.0, 1.0)) # If the observation is in the future, calculate what delays will be used, instead of using the recorded actual delays if su.tai2gps(s_obstime) > su.tai2gps(su.time2tai()) + 10: if 0 in obsinfo['rfstreams']: delays = calc_delays(az=obsinfo['rfstreams'][0]['azimuth'], el=obsinfo['rfstreams'][0]['elevation']) elif '0' in obsinfo['rfstreams']: delays = calc_delays(az=obsinfo['rfstreams']['0']['azimuth'], el=obsinfo['rfstreams']['0']['elevation']) else: delays = [33] * 16 logger.debug("Calculated future delays: %s" % delays) else: if 0 in obsinfo['rfstreams']: delays = obsinfo['rfstreams'][0]['xdelays'] elif '0' in obsinfo['rfstreams']: delays = obsinfo['rfstreams']['0']['xdelays'] logger.debug("Used actual delays: %s" % delays) # get the primary beam R = primarybeammap.return_beam(Alt, Az, delays, channel * 1.28) # show the beam X, Y = bmap(skydata.skymapRA, skydata.skymapDec) CS = bmap.contour(bmap.xmax - X, Y, R, contours, linewidths=plotscale, colors=beamcolor) ax1.clabel(CS, inline=1, fontsize=10 * plotscale) # Find the constellation that the beam is in if obsinfo['ra_phase_center'] is not None: ra = obsinfo['ra_phase_center'] dec = obsinfo['dec_phase_center'] else: ra = obsinfo['metadata']['ra_pointing'] dec = obsinfo['metadata']['dec_pointing'] if (ra is not None) and (dec is not None): constellation = ephem.constellation((ra * math.pi / 180.0, dec * math.pi / 180.0)) else: constellation = ["N/A", "N/A"] X0, Y0 = bmap(LST_hours.hour * 15 - 360, su.MWA_TOPO.latitude.degrees) if constellations: # plot the constellations ConstellationStars = [] for c in skydata.constellations.keys(): for i in range(0, len(skydata.constellations[c][1]), 2): i1 = numpy.where(skydata.hip['HIP'] == skydata.constellations[c][1][i])[0][0] i2 = numpy.where(skydata.hip['HIP'] == skydata.constellations[c][1][i + 1])[0][0] star1 = skydata.hip[i1] star2 = skydata.hip[i2] if i1 not in ConstellationStars: ConstellationStars.append(i1) if i2 not in ConstellationStars: ConstellationStars.append(i2) ra1, dec1 = map(numpy.degrees, (star1['RArad'], star1['DErad'])) ra2, dec2 = map(numpy.degrees, (star2['RArad'], star2['DErad'])) ra = numpy.array([ra1, ra2]) dec = numpy.array([dec1, dec2]) newx, newy = bmap(ra, dec) testx, testy = bmap(newx, newy, inverse=True) if testx.max() < 1e30 and testy.max() < 1e30: bmap.plot(2 * X0 - newx, newy, 'r-', linewidth=plotscale, latlon=False) # This bit generates an error # figure out the coordinates # and plot the stars ra = numpy.degrees(skydata.hip[ConstellationStars]['RArad']) dec = numpy.degrees(skydata.hip[ConstellationStars]['DErad']) m = numpy.degrees(skydata.hip[ConstellationStars]['Hpmag']) newx, newy = bmap(ra, dec) # testx, testy = bmap(newx, newy, inverse=True) good = (newx > bmap.xmin) & (newx < bmap.xmax) & (newy > bmap.ymin) & (newy < bmap.ymax) size = 60 - 15 * m size[size <= 15] = 15 size[size >= 60] = 60 bmap.scatter(bmap.xmax - newx[good], newy[good], size[good] * plotscale, 'r', edgecolor='none', alpha=0.7) if gleamsources: ra = numpy.array([x[1] for x in skydata.gleamcat]) dec = numpy.array([x[2] for x in skydata.gleamcat]) flux = numpy.array([x[3] for x in skydata.gleamcat]) newx, newy = bmap(ra, dec) # testx, testy = bmap(newx, newy, inverse=True) good = (newx > bmap.xmin) & (newx < bmap.xmax) & (newy > bmap.ymin) & (newy < bmap.ymax) size = flux / 1.0 size[size <= 7] = 7 size[size >= 60] = 60 bmap.scatter(bmap.xmax - newx[good], newy[good], size[good] * plotscale, 'b', edgecolor='none', alpha=0.7) # plot the bodies for b in skydata.bodies.keys(): name = skydata.bodies[b][2] color = skydata.bodies[b][1] if inverse: if name == 'Moon': color = 'darkgoldenrod' elif name == 'Jupiter': color = 'sienna' elif name == 'Saturn': color = 'purple' size = skydata.bodies[b][0] body_app = observer.observe(b).apparent() body_ra_a, body_dec_a, _ = body_app.radec() ra, dec = body_ra_a._degrees, body_dec_a.degrees newx, newy = bmap(ra, dec) testx, testy = bmap(newx, newy, inverse=True) if testx < 1e30 and testy < 1e30: bmap.scatter(2 * X0 - newx, newy, s=size * plotscale, c=color, alpha=1.0, latlon=False, edgecolor='none') ax1.text(bmap.xmax - newx + 2e5, newy, name, horizontalalignment='left', fontsize=12 * plotscale, color=color, verticalalignment='center') # and label some sources for source in primarybeammap.sources.keys(): if source == 'EOR0b': continue if source == 'CenA': primarybeammap.sources[source][0] = 'Cen A' if source == 'ForA': primarybeammap.sources[source][0] = 'For A' r = Longitude(angle=primarybeammap.sources[source][1], unit=astropy.units.hour).hour d = Latitude(angle=primarybeammap.sources[source][2], unit=astropy.units.deg).deg horizontalalignment = 'left' x = r if (len(primarybeammap.sources[source]) >= 6 and primarybeammap.sources[source][5] == 'c'): horizontalalignment = 'center' x = r if (len(primarybeammap.sources[source]) >= 6 and primarybeammap.sources[source][5] == 'r'): horizontalalignment = 'right' x = r fontsize = primarybeammap.defaultsize if (len(primarybeammap.sources[source]) >= 5): fontsize = primarybeammap.sources[source][4] color = primarybeammap.defaultcolor if (len(primarybeammap.sources[source]) >= 4): color = primarybeammap.sources[source][3] if color == 'k': color = 'w' if inverse: if color == 'w': color = 'black' xx, yy = bmap(x * 15 - 360, d) try: if xx < 1e30 and yy < 1e30: ax1.text(bmap.xmax - xx + 2e5, yy, primarybeammap.sources[source][0], horizontalalignment=horizontalalignment, fontsize=fontsize * plotscale, color=color, verticalalignment='center') except: pass if not notext: if background == 'black': fontcolor = 'white' else: fontcolor = 'black' if showbeam: ax1.text(0, bmap.ymax - 2e5, 'Obs ID %d with delays %s\n at %s:\n%s at %d MHz\n in the constellation %s' % (obsinfo['starttime'], delays, a_obstime.datetime.strftime('%Y-%m-%d %H:%M UT'), obsinfo['obsname'], channel * 1.28, constellation[1]), fontsize=10 * plotscale, color=fontcolor) else: ax1.text(0, bmap.ymax - 2e5, '%s:\nNo recent observation' % (a_obstime.datetime.strftime('%Y-%m-%d %H:%M UT')), fontsize=10 * plotscale, color=fontcolor) ax1.text(bmap.xmax, Y0, 'W', fontsize=12 * plotscale, horizontalalignment='left', verticalalignment='center') ax1.text(bmap.xmin, Y0, 'E', fontsize=12 * plotscale, horizontalalignment='right', verticalalignment='center') ax1.text(X0, bmap.ymax, 'N', fontsize=12 * plotscale, horizontalalignment='center', verticalalignment='bottom') ax1.text(X0, bmap.ymin, 'S', fontsize=12 * plotscale, horizontalalignment='center', verticalalignment='top') try: if type(outfile) == str: if not xmas: if background.lower() == 'transparent': fig.savefig(outfile, transparent=True, facecolor='none', dpi=DPI) else: fig.savefig(outfile, transparent=False, facecolor=background, dpi=DPI) return '' else: buf = io.BytesIO() if background.lower() == 'transparent': fig.savefig(buf, format='png', transparent=True, facecolor='none', dpi=DPI) else: fig.savefig(buf, format='png', transparent=False, facecolor=background, dpi=DPI) buf.seek(0) im = Image.open(buf) im.load() buf.close() r = Image.open('Treindeers.png') im.paste(r, box=(250, 300), mask=r) buf2 = io.BytesIO() im.save(buf2, format=outfile[outfile.find('.') + 1:].upper()) buf2.seek(0) outf = open(outfile, 'wb') outf.write(buf2.read()) return '' else: buf = io.BytesIO() if background.lower() == 'transparent': fig.savefig(buf, format='png', transparent=True, facecolor='none', dpi=DPI) else: fig.savefig(buf, format='png', transparent=False, facecolor=background, dpi=DPI) buf.seek(0) if not xmas: return buf.read() else: im = Image.open(buf) im.load() buf.close() r = Image.open('Treindeers.png') im.paste(r, box=(250, 100), mask=r) buf2 = io.BytesIO() im.save(buf2, format='PNG') buf2.seek(0) return buf2.read() except AssertionError: logger.error('Cannot save output: %s', outfile) return None finally: plt.close(fig) del ax1 del fig
#with open(filename) as jfile: # rjsJ = json.load(jfile) #====================================================================== df = pd.DataFrame(rjsJ, dtype=np.float32) vplt = plt.figure(figsize=(10, 8), edgecolor=None) #ax1 = vplt.add_axes([0.05, 0.80, 0.9, 0.15]) m = Basemap(llcrnrlon=-125.671, llcrnrlat=24.4769, urcrnrlon=-66.5202, urcrnrlat=49.4391, epsg=4326) #http://server.arcgisonline.com/arcgis/rest/services #try local copy first try: from PIL import Image m.imshow(Image.open('USAStreetMap.png'), origin='upper', alpha=0.6) except FileNotFoundError as err: #arcgisimage occasionally fails to download properly try,try again while True: try: m.arcgisimage(service='ESRI_StreetMap_World_2D', xpixels=3500, alpha=0.6) except RuntimeError as err: pass else: break #--------------------------------------------------------------------- vvmin = -10 #min temp for scale vvmax = 50 #max temp for scale vstep = 10 #step between ticks
# north polar projection. m = Basemap(lon_0=-135,boundinglat=25,round=True, resolution='c',area_thresh=10000.,projection='npstere') # transform from spherical to map projection coordinates (rotation # and interpolation). nxv = 41; nyv = 41 nxp = 101; nyp = 101 spd = np.sqrt(u**2+v**2) udat, vdat, xv, yv = m.transform_vector(u,v,lons1,lats1,nxv,nyv,returnxy=True) pdat, xp, yp = m.transform_scalar(p,lons1,lats1,nxp,nyp,returnxy=True) # create a figure, add an axes. fig=plt.figure(figsize=(8,8)) ax = fig.add_axes([0.1,0.1,0.7,0.7]) # plot image over map im = m.imshow(pdat,plt.cm.jet) # plot wind vectors over map. Q = m.quiver(xv,yv,udat,vdat) #or specify, e.g., width=0.003, scale=400) qk = plt.quiverkey(Q, 0.95, 1.05, 25, '25 m/s', labelpos='W') m.colorbar(pad='12%') # draw colorbar m.drawcoastlines() m.drawcountries() # draw parallels delat = 20. circles = np.arange(0.,90.+delat,delat).tolist()+\ np.arange(-delat,-90.-delat,-delat).tolist() m.drawparallels(circles,labels=[1,1,1,1]) # draw meridians delon = 45. meridians = np.arange(-180,180,delon) m.drawmeridians(meridians,labels=[1,1,1,1])
else: min = d.min() #p.subplot(m2, m1, cnt+1) if not opts.nogrid: from mpl_toolkits.basemap import Basemap xpx,ypx = d.shape dx1 = -(xpx/2 + .5) * kwds['d_ra'] * a.img.deg2rad dx2 = (xpx/2 - .5) * kwds['d_ra'] * a.img.deg2rad dy1 = -(ypx/2 + .5) * kwds['d_dec'] * a.img.deg2rad dy2 = (ypx/2 - .5) * kwds['d_dec'] * a.img.deg2rad map = Basemap(projection='ortho', lon_0=180, lat_0=kwds['dec'], rsphere=1, llcrnrx=dx1, llcrnry=dy1, urcrnrx=dx2,urcrnry=dy2) map.drawmeridians(n.arange(kwds['ra']-180,kwds['ra']+180,30)) map.drawparallels(n.arange(-90,120,30)) map.drawmapboundary() map.imshow(d, vmin=min, vmax=max, cmap=cmaps[cnt%len(cmaps)], interpolation='nearest', alpha=1-.25*cnt) else: p.imshow(d, vmin=min, vmax=max, origin='lower', cmap=cmap, interpolation='nearest') p.colorbar(shrink=.5, fraction=.05) p.title(filename) if opts.batch: print 'Saving to', outfile p.savefig(outfile) p.clf() # Add right-click functionality for finding locations/strengths in map. cnt = 1 def click(event): global cnt if not event.button in [2,3]: return
#plot the beam contours if not opts.beam is None: bm_levels = [0.0001, 0.001, 0.01, 0.1, 0.5, 0.9] #beam levels in beam units print "plotting beam contours: %s" % ([db(bm) for bm in bm_levels]) lons, lats, x_bm, y_bm = map.makegrid(360 / opts.res, 180 / opts.res, returnxy=True) map.contour(x_bm, y_bm, bm_response**2, bm_levels, colors='r', lw=10) if opts.skip_im: pass if opts.osys == 'ga': print data.shape data = n.fliplr(data) print data.shape map.imshow(data, vmax=max, vmin=min, cmap=cmap, interpolation=opts.interp) ax.format_coord = format_coord # Plot src labels and markers on top of map image if not opts.src is None: print "trying to plot sources" sx, sy = map(slons, slats) for name, xpt, ypt, flx in zip(snams, sx, sy, sflxs): if xpt >= 1e30 or ypt >= 1e30: continue #if opts.src_mark != '': #map.plot(sx, sy, opts.src_color+opts.src_mark,markerfacecolor=None) #map.scatter(sx,sy,'o',color=[(181,237,255)]*len(sx),s=n.log10(flx)*10) if opts.lockview and flx < 40: continue if flx < 60: s = 10
topodat = m.transform_scalar(data, lons, lats, nx, ny) print 'Getting colormap...' # get colormap #cptfile = '//Users//tallen//Documents//DATA//GMT//cpt//mby_topo-bath_mod.cpt' cptfile = '//Users//tallen//Documents//DATA//GMT//cpt//mby_topo-bath.cpt' #cptfile = '//Users//tallen//Documents//DATA//GMT//cpt//gray.cpt' cmap, zvals = cpt2colormap(cptfile, 256) cmap = remove_last_cmap_colour(cmap) # make shading print 'Making map...' ls = LightSource(azdeg=180, altdeg=45) norm = mpl.colors.Normalize(vmin=-8000 / zscale, vmax=5000 / zscale) #myb rgb = ls.shade(topodat, cmap=cmap, norm=norm) im = m.imshow(rgb) ########################################################################################## # plt boundaries ########################################################################################## x, y = m(walon, walat) plt.plot(x, y, '-', c='r', lw=2.5) labelCentroid(plt, m, 'WA', 16, walon, walat, 0) x, y = m(ealon, ealat) plt.plot(x, y, '-', c='r', lw=2.5) labelCentroid(plt, m, 'EA', 16, ealon, ealat, 0) x, y = m(salon, salat) plt.plot(x, y, '-', c='r', lw=2.5)
def run_main(): """ Main """ print "Crawling last near real-time true-color image from MODIS... ", download(URL_RAPIDFIRE_SUBSET, "data.zip") try: zipf = zipfile.ZipFile('data.zip') except zipfile.BadZipfile: print "\n\n\tError: BadZipfile, maybe the data is not yet ready on MODIS site !\n" sys.exit(-1) tempdir = tempfile.mkdtemp() for name in zipf.namelist(): data = zipf.read(name) outfile = os.path.join(tempdir, name) f = open(outfile, 'wb') f.write(data) f.close() zipf.close() image_path = os.path.join(tempdir, IMAGE_FILE) image_modis = Image.open(image_path) print "done !" print "Downloading MODIS image metadata... ", metadata = downloadString(URL_METADATA) ll_lon = parseTerm(metadata, "LL lon") ll_lat = parseTerm(metadata, "LL lat") ur_lon = parseTerm(metadata, "UR lon") ur_lat = parseTerm(metadata, "UR lat") print "done !" print "Downloading shape files from MODIS rapid fire... ", download(URL_FIRE_SHAPES, "shapes.zip") zipf = zipfile.ZipFile('shapes.zip') for name in zipf.namelist(): data = zipf.read(name) outfile = os.path.join(tempdir, name) f = open(outfile, 'wb') f.write(data) f.close() zipf.close() print "done !" print "Parsing shapefile... ", shape_path = os.path.join(tempdir, 'Global_%s' % FIRE_LASTS) r = shapefile.Reader(shape_path) # print r.fields sr = r.shapeRecords() total = len(sr) xlist = [] ylist = [] confidence = [] for i in xrange(total): sr_test = sr[i] xlist.append(sr_test.shape.points[0][0]) #longitude ylist.append(sr_test.shape.points[0][1]) #latitude confidence.append(sr_test.record[8]) print "done !" print "Rendering... ", m = Basemap(projection='cyl', llcrnrlat=ur_lat, urcrnrlat=ll_lat,\ llcrnrlon=ll_lon, urcrnrlon=ur_lon, resolution='f') m.drawcoastlines() m.drawmapboundary(fill_color='aqua') m.scatter(xlist, ylist, 20, c=confidence, cmap=p.cm.YlOrRd, marker='o', edgecolors='none', zorder=10) m.imshow(image_modis) p.title( "The recent fire hotspots for last %s \n Pixel size: %s | Current Date: %s | Area Mapped: %s" % (FIRE_LASTS, RAPIDFIRE_RES, time.strftime("%d/%m/%Y"), SUBSET_NAME)) p.show() os.remove("data.zip")
def initialize(self): font = {'size': 12} matplotlib.rc('font', **font) matplotlib.style.use("dark_background") pixels = [1920, 1080] fig = Figure(figsize=(pixels[0] / 96.0, pixels[1] / 96.0), edgecolor='none', facecolor='k') i0 = 1 i = 14 j = 36 s = 3 # ---------------------------------------------------------------------- # Eixos para os graficos # ---------------------------------------------------------------------- gs1, gs2 = gridspec.GridSpec(i, j), gridspec.GridSpec(i, j) # ---------------------------------------------------------------------- # Grafico de temperatura xaxis compartilhado com os demais graficos graf_temp = fig.add_subplot(gs1[i0 + 3 * s:i0 + 4 * s:11, 0:15]) # Grafico de pressao graf_press = fig.add_subplot(gs1[i0 + 2 * s:i0 + 3 * s:11, 0:15], sharex=graf_temp) # Grafico umidade e precipitacao graf_umid = fig.add_subplot(gs1[i0 + s:i0 + 2 * s, 0:15], sharex=graf_temp) graf_rain = graf_umid.twinx() # Grafico de vento e direcao do vento graf_vento = fig.add_subplot(gs1[i0:i0 + s, 0:15], sharex=graf_temp) # ---------------------------------------------------------------------- # Icone da pressao icon_pres = fig.add_subplot(gs1[i0 + 2 * s:i0 + 3 * s, 16:21], frameon=False) # Icone do vento icon_vent = fig.add_subplot(gs1[i0:i0 + s, 16:18], frameon=False) # Icone de umidade icon_umid = fig.add_subplot(gs1[i0 + s:i0 + 2 * s, 16:18], frameon=False) # Icone de temperatura icon_temp = fig.add_subplot(gs1[i0 + 3 * s:i0 + 4 * s, 16:18], frameon=False) # Icone direcao do vento agora icon_vento_dir = fig.add_subplot(gs2[i0:i0 + s, 19:22], frameon=False, projection='polar') # Icone de precipitacao icon_rain = fig.add_subplot(gs2[i0 + s:i0 + 2 * s, 18:21], frameon=False) # Icone de sensação térmica self.icon_feel = fig.add_subplot(gs2[i0 + 3 * s:i0 + 4 * s, 18:21], frameon=False) # Icone de rajada icon_gust = fig.add_subplot(gs1[i0:4, 23:27], frameon=False) # Icone de windrose icon_rose = fig.add_subplot(gs1[i0:4, 28:32], frameon=False, projection='polar') # ---------------------------------------------------------------------- # Titulo Gráficos self.title_1 = fig.add_subplot(gs1[0, 0:12], frameon=False) # Titulo Icones self.title_2 = fig.add_subplot(gs1[0, 16:21], frameon=False) # Titulo Logos self.title_3 = fig.add_subplot(gs1[-2, 23::], frameon=False) map = fig.add_subplot(gs1[5:-2, 23::]) gs1.update(wspace=0.01, hspace=0.3, left=0.04, top=1, bottom=0.000001) gs2.update(wspace=0.03, hspace=0.75, top=1, bottom=0.000001) # ---------------------------------------------------------------------- # Plota os icones # ---------------------------------------------------------------------- dir_icon = '.\images' zoom_f = 1.6 kw = dict(frameon=False, xycoords="data", boxcoords="data", xy=(0, 0), box_alignment=(0.0, 0.0)) # Desenha os icones de vento img_today = read_png(os.path.join(dir_icon, 'wind.png')) imagebox = OffsetImage(img_today, zoom=0.07 * zoom_f) ab = AnnotationBbox(imagebox, xybox=(0.1, 0.1), **kw) icon_vent.add_artist(ab) # ---------------------------------------------------------------------- # Gerando eixo polar para as setas para o vento directions = ['N', 'NW', 'W', 'SW', 'S', 'SE', 'E', 'NE'] icon_vento_dir.set_theta_zero_location('N') icon_vento_dir.set_theta_direction(1) icon_vento_dir.set_xticklabels(directions) icon_vento_dir.tick_params(axis='x', colors='w') icon_vento_dir.tick_params(axis='y', colors='w') icon_vento_dir.grid(color='w') # Desenha o icone de rajada img_today = read_png(os.path.join(dir_icon, 'rajada.png')) imagebox = OffsetImage(img_today, zoom=0.15 * zoom_f) ab = AnnotationBbox(imagebox, xybox=(0.0, 0.1), **kw) icon_gust.add_artist(ab) icon_gust.set_title(u'Rajada 2 minutos', fontsize=11, x=0.4, y=1, fontweight='bold') # ---------------------------------------------------------------------- # Gerando eixo polar para plot icon_rose.set_theta_zero_location('N') icon_rose.set_theta_direction(1) icon_rose.set_xticklabels(directions) icon_rose.tick_params(axis='x', colors='w') icon_rose.tick_params(axis='y', colors='w') icon_rose.grid(color='w') # Desenha os icones de umidade img_today = read_png(os.path.join(dir_icon, 'humidity.png')) imagebox = OffsetImage(img_today, zoom=0.075 * zoom_f) ab = AnnotationBbox(imagebox, xybox=(0.325, 0.10), **kw) icon_umid.add_artist(ab) # Desenha os icones de precipitacao img_today = read_png(os.path.join(dir_icon, 'rain.png')) imagebox = OffsetImage(img_today, zoom=0.09 * zoom_f) ab = AnnotationBbox(imagebox, xybox=(0.275, 0.0), **kw) icon_rain.add_artist(ab) # Desenha os icones de pressao img_today = read_png(os.path.join(dir_icon, 'pressure.png')) imagebox = OffsetImage(img_today, zoom=0.125 * zoom_f) ab = AnnotationBbox(imagebox, xybox=(0.35, 0.0), **kw) icon_pres.add_artist(ab) # Desenha os icones de temperatura img_today = read_png(os.path.join(dir_icon, 'temp.png')) imagebox = OffsetImage(img_today, zoom=0.11 * zoom_f) ab = AnnotationBbox(imagebox, xybox=(0.22, 0.0), **kw) icon_temp.add_artist(ab) # Desenha o icone de sensacao termica atual img_today = read_png(os.path.join(dir_icon, 'realfeel.png')) imagebox = OffsetImage(img_today, zoom=0.10 * zoom_f) self.ab = AnnotationBbox(imagebox, xybox=(0.3, 0.1), **kw) self.icon_feel.add_artist(self.ab) self.icon_feel.set_title(u'Sensação\nTérmica', fontsize=11, x=0.55, y=-0.2) self.img = itertools.cycle( ['realfeel_cky.png', 'realfeel_fms.png', 'realfeel_fna.png']) # logo Petrobras img_today = read_png(os.path.join(dir_icon, 'Principal_h_cor_RGB.png')) imagebox = OffsetImage(img_today, zoom=0.2) # opcao 1: logo ao lado do credito ab = AnnotationBbox(imagebox, xybox=(0.0, 0.05), **kw) self.title_3.add_artist(ab) # logo Oceanop img_today = read_png(os.path.join(dir_icon, 'oceanop_logo.png')) imagebox = OffsetImage(img_today, zoom=0.4) # opcao 1: logo ao lado do credito ab = AnnotationBbox(imagebox, xybox=(0.8, 0.1), **kw) self.title_3.add_artist(ab) # ---------------------------------------------------------------------- # Cria mapa base # ---------------------------------------------------------------------- # Coordenadas da estacao meteorologica # 22 24 4.02**41 48 29.30 Xest, Yest = -41.808138888889, -22.401116666667 # Coordenadas da janela da imagem 2223.936_4148.723_2224.175_4148.264 Xmin, Xmax = -41.81205, -41.8044 Ymin, Ymax = -22.402916666667, -22.398933333333 # Mapa base com a localizacao da estacao m = Basemap(ax=map, epsg=4326, projection='merc', llcrnrlat=Ymin, urcrnrlat=Ymax, llcrnrlon=Xmin, urcrnrlon=Xmax, resolution='c') imgfile = os.path.join(dir_icon, '2223.936_4148.723_2224.175_4148.264.jpg') img = plt.imread(imgfile) m.imshow(img, origin='upper') # Plota pontos de interesse bprops = dict(boxstyle='round', facecolor='w', alpha=0.35) aprops2 = dict(arrowstyle='simple', connectionstyle='arc3, rad=-0.2', relpos=(0., 1.), facecolor='k', alpha=0.6) map.text(-41.8066588889, -22.40111, 'EDINC', horizontalalignment='center', verticalalignment='center', fontweight='bold', fontsize=16, color='k', bbox=bprops) pest, = map.plot(Xest, Yest, 'ro', markersize=4) map.annotate(u"Estação\nMeteorológica", xy=(Xest, Yest), xycoords='data', xytext=(-41.809, -22.403), size=12, va='top', ha='left', arrowprops=aprops2, bbox=bprops, fontweight='bold') # Insere seta apontando para o norte no canto inferior direito imgfile = read_png(os.path.join(dir_icon, 'north_arrow.png')) imagebox = OffsetImage(imgfile, zoom=0.11) lonmin, lonmax = m.boundarylonmin, m.boundarylonmax latmin, latmax = min(m.boundarylats), max(m.boundarylats) xy = (lonmax - 0.08 * (lonmax - lonmin), latmax - 0.9 * (latmax - latmin)) ab = AnnotationBbox(imagebox, xy, frameon=False, xycoords="data", boxcoords="data", box_alignment=(0.0, 0.0)) map.add_artist(ab) fontdict = { 'color': 'w', 'va': 'center', 'ha': 'center', 'fontsize': 13, 'fontweight': 'bold' } self.i_vent = icon_vent.text(0.5, 0.8, 'NA', fontdict=fontdict) self.i_gust = icon_gust.text(0.5, 0.8, 'NA', fontdict=fontdict) self.i_umid = icon_umid.text(0.5, 0.75, 'NA', fontdict=fontdict) self.i_rain = icon_rain.text(0.5, 0.8, 'NA', fontdict=fontdict) self.i_pres = icon_pres.text(0.2, 0.7, 'NA', fontdict=fontdict) self.i_temp = icon_temp.text(0.25, 0.75, 'NA', fontdict=fontdict) self.i_feel = self.icon_feel.text(0.275, 0.75, 'NA', fontdict=fontdict) # Set icones e titulos axis_icon_names = [ icon_pres, icon_vent, icon_umid, icon_rain, icon_gust, icon_pres, icon_temp, self.icon_feel, self.title_1, self.title_2, self.title_3 ] for i in axis_icon_names: i.set_axis_off() # Set titulos nos graficos graf_vento.set_title(u'Vento [km/h]', x=0.12, y=0.75, fontweight='bold', fontsize=11) graf_press.set_title(u'Pressão Atmosférica [hPa]', x=0.23, y=0.75, fontweight='bold', fontsize=11) graf_umid.set_title(u'Umidade Relativa [%]', x=0.19, y=0.75, fontweight='bold', fontsize=11) graf_temp.set_title(u'Temperatura do Ar [\N{DEGREE SIGN}C]', x=0.205, y=0.75, fontweight='bold', fontsize=11) map.set_title(u'Localização da Estação Meteorólogica', fontsize=15, fontweight='bold', loc='left', y=1.05) self.canvasFig = fig # [0]wind, [1]humi, [2]pres, [3]temp self.cor = ['#4CB050', '#2196F5', '#FF9702', '#F44236'] x, y = [], [] self.line0, = graf_vento.plot(x, y, self.cor[0]) self.line1, = graf_umid.plot(x, y, self.cor[1]) self.line2, = graf_rain.plot(x, y, self.cor[1], linestyle='--') self.line3, = graf_press.plot(x, y, self.cor[2]) self.line4, = graf_temp.plot(x, y, self.cor[3]) icon_vento_dir.axes.yaxis.set_ticklabels([]) icon_rose.axes.yaxis.set_ticklabels([]) self.canvas = FigureCanvasTkAgg(fig, master=self) self.canvas.show() self.canvas.get_tk_widget().pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) self.canvas._tkcanvas.pack(side=Tkinter.TOP, fill=Tkinter.BOTH, expand=1) self.after(500, self.icon_refresh, icon_vento_dir, icon_rose) self.update()
def visualize_ensemble_raster(crop, osc, raster_data, raster_mask, savepath, save, cmap, colorbar_name, data_type): # Initialize the map figure using Basemap m = Basemap( projection='cyl', resolution='c', llcrnrlat=-60, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180, ) fig = plt.figure() ax = plt.Axes(fig, [0., 0., 1., 1.]) ax.set_axis_off() fig.add_axes(ax) # Create the colorscale, using RGB information and the function LinearSegmentedColormap if cmap == 'redblue': cdict = { 'blue': ((0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.49, 0.8, 0.9), (0.51, 0.9, 1.0), (0.75, 1.0, 1.0), (1.0, 0.4, 1.0)), 'green': ((0.0, 0.0, 0.0), (0.25, 0.0, 0.0), (0.49, 0.9, 0.9), (0.51, 0.9, 0.9), (0.75, 0.0, 0.0), (1.0, 0.0, 0.0)), 'red': ((0.0, 0.0, 0.4), (0.25, 1.0, 1.0), (0.49, 1.0, 0.9), (0.51, 0.9, 0.8), (0.75, 0.0, 0.0), (1.0, 0.0, 0.0)) } clim = (-5, 5) cbar_label = 'Crop yield deviation (%) per unit index change' cmap = LinearSegmentedColormap('cmap', cdict) elif cmap == 'whiteblue': cdict = { 'blue': ((0.0, 0.8, 0.9), (0.01, 0.9, 1.0), (0.5, 1.0, 1.0), (1.0, 0.4, 1.0)), 'green': ((0.0, 0.9, 0.9), (0.01, 0.9, 0.9), (0.5, 0.0, 0.0), (1.0, 0.0, 0.0)), 'red': ((0.0, 1.0, 0.9), (0.01, 0.9, 0.8), (0.5, 0.0, 0.0), (1.0, 0.0, 0.0)) } clim = (0, 100) cbar_label = 'Proportion of individual models that agree with the ensemble sensitivity sign' cmap = LinearSegmentedColormap('cmap', cdict) # Modify settings for the raster visualization. raster_data = np.flipud(raster_data) raster_mask = np.flipud(raster_mask) mask_index = raster_mask * np.isnan(raster_data) raster_data[mask_index] = 0 cs = m.imshow(raster_data[60:, :] * 100, clim=clim, cmap=cmap) m.drawcoastlines(linewidth=0.25) # m.drawcountries(linewidth=0.25) m.fillcontinents(color='white', lake_color='white', zorder=0) m.drawmapboundary(fill_color='White') # Save the figure. if save == 1: os.chdir(savepath) plt.savefig(crop + '_' + osc + '_' + data_type + '.png', dpi=300, bbox_inches='tight') plt.show(m) # If colorbar for sensitivity doesn't exist in folder, create it. if colorbar_name not in os.listdir(savepath): # add colorbar plt.figure() cs = plt.imshow(raster_data[60:, :] * 100, clim=clim, cmap=cmap) plt.gca().set_visible(False) cbar = plt.colorbar(cs, extend='both', orientation='horizontal') cbar.set_label(cbar_label, fontsize=12) plt.savefig(colorbar_name, dpi=300, bbox_inches='tight')
zl = zl[::d][:,::d] return xl, yl, zl lont, latt, zt = get_xyz() zt = zt.T lont, latt = np.meshgrid(lont, latt) # n = 1000 # nx = 1 + int( (map.xmax-map.xmin)/n ) # ny = 1 + int( (map.ymax-map.ymin)/n ) nx = 2000; ny = 3000 topodat = map.transform_scalar(zt, lont[0,:], latt[:,0], nx, ny) # im = map.imshow(topodat * 0 + 1, cmap=plt.get_cmap('Greys'), alpha = 1,interpolation = 'bilinear', rasterized=True) im = map.imshow(topodat, cmap=plt.get_cmap('terrain'), alpha = 1,interpolation = 'bilinear', rasterized=True) xt, yt = map(lont, latt) ls = LightSource(azdeg=315, altdeg=45) hs = ls.hillshade(zt, vert_exag = 2, dx=xt[0,1] - xt[0,0] , dy=yt[0,0] - yt[1,0]) hs = map.transform_scalar(hs, lont[0,:], latt[:,0], nx, ny) map.imshow(hs, cmap = 'gray', alpha = .5,interpolation = 'bilinear', rasterized=True) #%% # plt.xlim([0, width]); plt.ylim([0, height]) # map.drawmapboundary(fill_color=None) # map.fillcontinents(color='lightgrey',lake_color=None) # map.shadedrelief() # map.etopo(scale = 1)
#y = y - ay #z = z - az try: data, indices = h[x, y, z] except (ValueError): data = h[x, y, z] data.shape = lats.shape map.drawmapboundary() map.drawmeridians(n.arange(0, 360, 30)) map.drawparallels(n.arange(0, 90, 10)) if opts.max is None: max = data.max() else: max = opts.max if opts.drng is None: min = data.min() # if min < (max - 10): min = max-10 else: min = max - opts.drng step = (max - min) / 10 levels = n.arange(min - step, max + step, step) print min, max #data = data.clip(min, max) #data = n.ma.array(data, mask=mask) #min=0 map.imshow(data, vmax=max, vmin=min, cmap=cmap) #map.contourf(cx,cy,data,levels,linewidth=0,cmap=cmap) p.colorbar() p.show()
masked_chan31 = np.ma.masked_invalid(chan31) fig, ax = plt.subplots(1, 1, figsize=(14, 14)) basemap_args = result_dict['basemap_args'] basemap_args['ax'] = ax basemap_args['resolution'] = 'c' bmap = Basemap(**basemap_args) lat_sep, lon_sep = 5, 5 parallels = np.arange(30, 60, lat_sep) meridians = np.arange(-135, -100, lon_sep) bmap.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10, latmax=90) bmap.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10, latmax=90) bmap.drawcoastlines(linewidth=1.5, linestyle='solid', color='k') with warnings.catch_warnings(): warnings.simplefilter("ignore") col = bmap.imshow(masked_chan31, origin='upper', norm=the_norm, cmap=cmap) cax, kw = matplotlib.colorbar.make_axes(ax, location='bottom', pad=0.05, shrink=0.7) out = fig.colorbar(col, cax=cax, extend='both', **kw) out.set_label('Chan 31 radiance (W/m^2/micron/sr)', size=20) ax.set_title('Chan 31 radiance vancouver', size=25) print(kw) # In[8]: wavel = 11.e-6 #chan 31 central wavelength, meters chan31_mks = result_dict['channels'][:, :, 0] * 1.e6 #W/m^2/m/sr Tbright = planckInvert(wavel, chan31_mks) Tbright = Tbright - 273.15 #convert to Centigrade
############################################################################## print('Reading netCDF file...') nc = NetCDFFile(ncf) data = nc.variables['z'][:] lons = nc.variables['x'][:] lats = nc.variables['y'][:] # transform to metres nx = int((m.xmax - m.xmin) / 500.) + 1 ny = int((m.ymax - m.ymin) / 500.) + 1 hazdat = m.transform_scalar(data, lons, lats, nx, ny) im = m.imshow(hazdat, cmap=cmap, norm=norm, alpha=1.0) ########################################################################################## # get land & lake polygons for masking ########################################################################################## # mask non-AU polygons nonmask = [0, 1, 2, 3, 4, 6, 7, 11, 13, 16, 17] # polygon number nonmask = [0, 9, 14, 17, 18, 19] # polygon number landpolys = [] for pidx, polygon in enumerate(m.landpolygons): maskPoly = True for nmidx in nonmask: if pidx == nmidx: maskPoly = False if maskPoly == True: poly = polygon.get_coords()
def main(): global inputArgs, grib, dir_path #Make our global vars: grib is the object that will hold our Grib Class. dir_path = os.path.dirname(os.path.realpath(__file__)) comparison_days = [0, -7] inputArgs = handle_args( sys.argv) #All input arguments if run on the command line. for deltaDay in comparison_days: # MAKE SURE TO UNCOMMENT #inputArgs.date2 when putting back into production if deltaDay == 0: date2 = None else: date2 = ((datetime.datetime.now(pytz.timezone('US/Pacific'))) + datetime.timedelta(days=deltaDay)).strftime("%Y%m%d") ############## # Debugging inputArgs.date = (datetime.datetime.today() - datetime.timedelta(days=1)).strftime("%Y%m%d") #inputArgs.date = time.strftime("%Y%m%d") #inputArgs.date = str(dayNum) inputArgs.date2 = date2 #Comment this out for just one date inputArgs.map = True # Make the map and save png to folder. inputArgs.plot = False findValueAtPoint = False # Find all the values at specific lat/lng points within an excel file. ################# grib = Grib() #Assign variable to the Grib Class. grib.model = inputArgs.model #Our model will always be "snodas" for this program grib.displayunits = inputArgs.displayunits grib.basin = inputArgs.basin # Basin can be "French_Meadows", "Hell_Hole", or "MFP", this gets shapefile # Bounding box will clip the raster to focus in on a region of interest (e.g. CA) This makes the raster MUCH smaller # and easier to work with. See gdal.Open -> gdal.Translate below for where this is acutally used. grib.bbox = [ -125.0, 50.0, -115.0, 30.0 ] #[upper left lon, upper left lat, lower left lon, lower left lat] grib = get_snowdas( grib, inputArgs.date ) #Get the snodas file and save data into the object variable grib #pngFile = makePNG() #Any reprojections of grib.gribAll have already been done in get_snowdas. #The original projection of snodas is EPSG:4326 (lat/lng), so it has been changed to EPSG:3875 (x/y) in get_snodas projInfo = grib.gribAll.GetProjection() geoinformation = grib.gribAll.GetGeoTransform( ) #Get the geoinformation from the grib file. xres = geoinformation[1] yres = geoinformation[5] xmin = geoinformation[0] xmax = geoinformation[0] + (xres * grib.gribAll.RasterXSize) ymin = geoinformation[3] + (yres * grib.gribAll.RasterYSize) ymax = geoinformation[3] spatialRef = osr.SpatialReference() spatialRef.ImportFromWkt(projInfo) spatialRefProj = spatialRef.ExportToProj4() # create a grid of xy (or lat/lng) coordinates in the original projection xy_source = np.mgrid[xmin:xmax:xres, ymax:ymin:yres] xx, yy = xy_source # A numpy grid of all the x/y into lat/lng # This will convert your projection to lat/lng (it's this simple). lons, lats = Proj(spatialRefProj)(xx, yy, inverse=True) # Find the center point of each grid box. # This says move over 1/2 a grid box in the x direction and move down (since yres is -) in the # y direction. Also, the +yres (remember, yres is -) is saying the starting point of this array will # trim off the y direction by one row (since it's shifted off the grid) xy_source_centerPt = np.mgrid[xmin + (xres / 2):xmax:xres, ymax + (yres / 2):ymin:yres] xxC, yyC = xy_source_centerPt lons_centerPt, lats_centerPt = Proj(spatialRefProj)(xxC, yyC, inverse=True) if grib.basin != "Hell_Hole": mask = createMask(xxC, yyC, spatialRefProj) grib.basinTotal, grib.basinSWE = calculateBasin( mask, grib, xres, yres) # The shape file for the Hell Hole basin includes the SMUD domain. Therefore, if we want to extract the SMUD # domain, then we will create another mask on top of the Hell Hole mask. This means that any grid point # outside of both domains will still = 0. The SMUD domain will contain it's mask AND the Hell Hole mask. if grib.basin == 'Hell_Hole': grib.basin = 'Hell_Hole_SMUD' #This is just to get the correct directory structure submask = createMask( xxC, yyC, spatialRefProj ) # All areas in array = to 1 will be in SMUD's basin smud_BasinArea = grib.basinArea # Used to remove SMUD's basin area (in m^2) from Hell_Hole's basin. # Get SMUD's information for the SMUD submask grib.SMUDbasinTotal, grib.SMUDbasinSWE = calculateBasin( submask, grib, xres, yres) grib.basin = 'Hell_Hole' # reset back mask = createMask( xxC, yyC, spatialRefProj ) #This will be the entire Hell Hole basin, which includes SMUD hhMask = mask + submask # Hell hole basin is now anywhere where hhMask = 1 and SMUD is anywhere it = 2 hhMask[hhMask != 1] = 0 # Set anything outside of Hell Hole's mask = 0 grib.basinArea = grib.basinArea - smud_BasinArea # grib.basinArea currently includes smuds basin, so remove it. # Get HellHoles's information from the hell hole submask grib.basinTotal, grib.basinSWE = calculateBasin( hhMask, grib, xres, yres) print("Current Basin Total: " + str(grib.basinTotal) + " SMUD Total: " + str(grib.SMUDbasinTotal)) #grib.basinTotal = grib.basinTotal - (0.92 * smudBasinTotal[0]) mask = hhMask # Need to do this so we can use the correct mask in compareDates and in calculateByElevation # Calculate the difference between two rasters if inputArgs.date2 != None: grib.basinTotal, grib.basinSWE = compareDates( mask, grib, xres, yres) #Need to do this after Hell_Hole's data has been manipulated (to account for SMUD) elevation_bins = calculateByElevation(mask, grib, xres, yres) #Send data for writing to Excel File if deltaDay == 0: excel_output(elevation_bins) if inputArgs.plot == True: makePlot(elevation_bins, deltaDay) print(elevation_bins) print(inputArgs.date, " Basin Total: ", grib.basinTotal) #findValue will return a dataframe with SWE values at various lat/lng points. df_ptVal = None if findValueAtPoint == True: df_ptVal = findPointValue(spatialRefProj, xy_source) if inputArgs.map == True: fig = plt.figure() ax = fig.add_subplot(111) m = Basemap(llcrnrlon=-122.8, llcrnrlat=37.3, urcrnrlon=-119.0, urcrnrlat=40.3, ax=ax) #m.arcgisimage(service='World_Imagery', xpixels=2000, verbose=True) im = Image.open( urlopen( "http://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-122.8,37.3,-119.0,40.3&bboxSR=4326&imageSR=4326&size=2000,1578&dpi=96&format=png32&transparent=true&f=image" )) m.imshow(im, origin='upper') #For inset # loc =>'upper right': 1, # 'upper left': 2, # 'lower left': 3, # 'lower right': 4, # 'right': 5, # 'center left': 6, # 'center right': 7, # 'lower center': 8, # 'upper center': 9, # 'center': 10 axin = inset_axes(m.ax, width="40%", height="40%", loc=8) m2 = Basemap(llcrnrlon=-120.7, llcrnrlat=38.7, urcrnrlon=-120.1, urcrnrlat=39.3, ax=axin) im2 = Image.open( urlopen( "http://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/export?bbox=-120.7,38.7,-120.09999999999998,39.3&bboxSR=4326&imageSR=4326&size=2000,1999&dpi=96&format=png32&transparent=true&f=image" )) m2.imshow(im2, origin='upper') #m2.arcgisimage(service='World_Imagery', xpixels=2000, verbose=True) mark_inset(ax, axin, loc1=2, loc2=4, fc="none", ec="0.5") ###################################DEBUGGING AREA############################################################### # Debugging: Test to prove a given lat/lng pair is accessing the correct grid box: #*********TEST 1: Test for center points #grib.data[0,0] = 15 #increase the variable by some arbitrary amount so it stands out. #xpts, ypts = m(lons_centerPt[0,0],lats_centerPt[0,0]) #This should be in the dead center of grid[0,0] #m.plot(xpts,ypts, 'ro') #*********TEST 2: Test for first grid box # Test to see a if the point at [x,y] is in the upper right corner of the cell (it better be!) #xpts, ypts = m(lons[0, 0], lats[0, 0]) # should be in upper right corner of cell #m.plot(xpts, ypts, 'bo') # *********TEST 3: Test for first grid box # Test to see the location of center points of each grid in polygon # To make this work, uncomment the variables in def create_mask #debug_Xpoly_center_pts, debug_Ypoly_center_pts = m(debugCenterX, debugCenterY) #m.plot(debug_Xpoly_center_pts, debug_Ypoly_center_pts, 'bo') # *********TEST 4: Test grid box size (In lat lng coords) # This is for use in a Basemap projection with lat/lon (e.g. EPSG:4326) #testX = np.array([[-120.1, -120.1], [-120.10833, -120.10833]]) #testY = np.array([[39.0, 39.00833], [39.0, 39.00833]]) # testVal = np.array([[4,4],[4,4]]) # For use in basemap projection with x/y (e.g. espg:3857. In m=basemap just include the argument projection='merc') # testX = np.array([[500975, 500975], [(500975 + 1172), (500975 + 1172)]]) # testY = np.array([[502363, (502363 + 1172)], [502363, (502363 + 1172)]]) #testVal = np.array([[18, 18], [18, 18]]) #im1 = m.pcolormesh(testX, testY, testVal, cmap=plt.cm.jet, vmin=0.1, vmax=10, latlon=False, alpha=0.5) # Test to see all points # xtest, ytest = m(lons,lats) # m.plot(xtest,ytest, 'bo') ################################################################################################################ hr = 0 makeMap(lons, lats, hr, m, m2, df_ptVal, deltaDay) return
llcrnrlat=22, urcrnrlon=-64, urcrnrlat=49, projection='lcc', lat_1=33, lat_2=45, lon_0=-95) # create masked array, reversing data in latitude direction # (so that data is oriented in increasing latitude, as transform_scalar requires). topoin = ma.masked_values(array[::-1, :], -999.) # transform DEM data to a 4 km native projection grid nx = int((m.xmax - m.xmin) / 4000.) + 1 ny = int((m.ymax - m.ymin) / 4000.) + 1 topodat = m.transform_scalar(topoin, lons, lats, nx, ny, masked=True) # plot DEM image on map. im = m.imshow(topodat, cmap=cm.GMT_haxby_r) # draw meridians and parallels. m.drawparallels(np.arange(20, 71, 10), labels=[1, 0, 1, 0]) m.drawmeridians(np.arange(-120, -40, 10), labels=[0, 1, 0, 1]) # plot state boundaries from shapefile using ogr. g = ogr.Open("st99_d00.shp") L = g.GetLayer(0) # data is in 1st layer. for feat in L: # iterate over features in layer geo = feat.GetGeometryRef() # iterate over geometries. for count in range(geo.GetGeometryCount()): geom = geo.GetGeometryRef(count) if not geom.GetGeometryCount(): # just one geometry. # get lon,lat points lons = [geom.GetX(i) for i in range(geom.GetPointCount())] lats = [geom.GetY(i) for i in range(geom.GetPointCount())]
topodat = m.transform_scalar(data, lons, lats, nx, ny) print('Getting colormap...') # get colormap cptfile = '//Users//trev//Documents//DATA//GMT//cpt//mby_topo-bath.cpt' #cptfile = '//Users//tallen//Documents//DATA//GMT//cpt//gray.cpt' cmap, zvals = cpt2colormap(cptfile, 256) cmap = remove_last_cmap_colour(cmap) # make shading print('Making map...') ls = LightSource(azdeg=180, altdeg=45) norm = mpl.colors.Normalize(vmin=-8000 / zscale, vmax=5000 / zscale) #myb rgb = ls.shade(topodat, cmap=cmap, norm=norm) im = m.imshow(rgb, alpha=0.6) ''' ########################################################################################## # add epicentres ########################################################################################## ncols = 18 # get year range minyear = 10*floor(cat.data['year'][0]/10.) maxyear = cat.data['year'][-1] yearrng = float(round(maxyear - minyear)) #cmap = plt.cm.get_cmap('Spectral', ncols) cptfile = '/Users/trev/Documents/DATA/GMT/cpt/temperature.cpt' #cptfile = '/Users/trev/Documents/DATA/GMT/cpt/grayscale08.cpt'
# -*- coding: utf-8 -*- """ Created on Thu Jun 13 15:54:40 2019 @author: Administrator """ from mpl_toolkits.basemap import Basemap import matplotlib.pyplot as plt from osgeo import gdal map = Basemap(projection='cyl', lat_0=0, lon_0=0, llcrnrlon=85, llcrnrlat=25, urcrnrlon=90, urcrnrlat=30) #读取tiff ds = gdal.Open("sample_files/dem/srtm_54_07.img") data = ds.ReadAsArray() map.imshow(data, cmap=plt.get_cmap('terrain'), alpha=0.5) plt.show()
class CoordinateHelper(object): def __init__(self, x=None,y=None, zone=None, zone_number=None, zone_letter=None, mm=None, bbox_expand=0.05, projection='merc', **kwargs): self.expand = bbox_expand if zone and not (zone_number and zone_letter): self._zone_number = int(zone[0:2]) self._zone_letter = zone[2:3] else: self._zone_number=zone_number self._zone_letter = zone_letter self.zone_numbers = None self.zone_letters = None self.set_xy(x,y) if not x is None: if not mm: self.mm = self.get_basemap(projection=projection, **kwargs) elif isinstance(mm, Basemap): self.mm = mm else: raise ValueError('bmap must be a mpl_toolkits.basemap.Basemap but is a {type(mm)}') def set_xy(self,x,y, ctype=None): self.x = np.array(x) self.y = np.array(y) if self.x.shape != self.y.shape: raise ValueError(f'x and y must have same shape! ({self.x.shape} != {self.y.shape})') if ctype in ['latlon', 'img', 'utm']: self.type = ctype else: self._detect_type() # try: if not self._zone_number is None: self.zone_numbers = np.tile(self._zone_number, self.x.shape) if not self._zone_letter is None: self.zone_letters = np.tile(self._zone_letter, self.x.shape) return self.zone_numbers, self.zone_letters = self._get_zones() # self.zone_numbers = zone_numbers # print(zone_numbers, zone_letters ) # self.zone_letter = zone_letter # and not self.zone_letter is None: # if (self.zone_number, self.zone_letter) != (zone_number, zone_letter): # Warning('The zone for the new data ((zone_number, zone_letter)} does not correspond to the zone already initialized ({self.zone_number, self.zone_letter}).') # except Exception as ex: # print(ex) def _detect_type(self): # print(self.y, type(self.y)) if all([np.all((-180<=c) & (c<=180)) for c in (self.x,self.y)]): self.type = 'latlon' y = self.y self.y = self.x self.x = y elif all([np.all((0<c) & (c<1e5)) for c in (self.x,self.y)]): self.type = 'img' elif all([np.all((0<c) & (c<1e7)) for c in (self.x,self.y)]): self.type = 'utm' else: raise ValueError('Could not detect coord type (latlon/utm/img) based on data ranges') print(f'{self.type} detected') def get_bbox_latlon(self, format='latlon'): lat,lon = self.to_latlon() lonm = lon.min() lonM = lon.max() latm = lat.min() latM = lat.max() lonex = (lonM-lonm)*self.expand/2 latex = (latM-latm)*self.expand/2 if format=='basemap': return { 'llcrnrlon':lonm - lonex, 'llcrnrlat':latm - latex, 'urcrnrlon':lonM + lonex, 'urcrnrlat':latM + latex } elif format[0:6]=='lonlat': bbox = ( lonm - lonex, latm - latex, lonM + lonex, latM + latex ) else: bbox = ( latm - latex, lonm - lonex, latM + latex, lonM + lonex ) if format[-1]==',': return (bbox[0:2], bbox[2:4]) else: return bbox def get_bbox_utm(self): bbox = self.get_bbox_latlon(format='latlon') return tuple([utm.from_latlon(lat, lon)[0:2] for lat,lon in zip(bbox[::2], bbox[1::2])]) def get_basemap(self, **kwargs): self.mm = Basemap(**self.get_bbox_latlon(format='basemap'), **kwargs) return self.mm def get_osm_zoom_level(self, bbox): m0 = 156412 bbox = self.get_bbox_latlon(format='latlon,') dlat = bbox[1][0]-bbox[0][0] dlon = bbox[1][1] - bbox[0][1] level_diff =np.abs(np.array([360/2**x for x in range(20)])-max(dlat, dlon)) level = level_diff.argmin()+2 print(f'OSM level {level} selected to display minimum {max(dlat, dlon)} degrees') return level def get_osm(self, *args, provider='osm', **kwargs): #geotiler cannot handle the bbox to be of type numpy, so convert to native floats: bbox = [x.item() for x in self.get_bbox_latlon(format='lonlat')] gm = geotiler.Map(extent=bbox, zoom=self.get_osm_zoom_level(bbox), provider=provider) self.img = geotiler.render_map(gm) return self.mm.imshow(self.img, *args, interpolation='lanczos', origin='upper', **kwargs) def to_img(self): if self.type=='img': return (self.x, self.y) else: if isinstance(self.mm, Basemap): if self.type=='latlon': return self.mm(self.x,self.y, latlon=True) elif self.type=='utm': f = np.vectorize(utm.to_latlon) return self.mm(f(self.x,self.y, zone_number=self.zone_numbers, zone_letter=self.zone_letters), latlon=True) else: raise AttributeError('Cannot convert image coordinates to latlon as no basemap is defined!') def to_utm(self): f = np.vectorize(utm.from_latlon) if self.type=='latlon': return f(self.x,self.y)[0:2] elif self.type=='utm': return (self.x, self.y) elif self.type=='img': if isinstance(self.mm, Basemap): return f(self.mm(self.x, self.y))[0:2] else: raise AttributeError('Cannot convert image coordinates to UTM as no basemap is defined!') def to_lonlat(self): lat, lon = self.to_latlon() return (lon, lat) def to_latlon(self): if self.type=='latlon': return (self.x, self.y) elif self.type=='utm': f = np.vectorize(utm.to_latlon) return f(self.x,self.y, zone_number=self.zone_numbers, zone_letter=self.zone_letters) elif self.type=='img': if isinstance(self.mm, Basemap): return self.mm(self.x, self.y) else: raise AttributeError('Cannot convert image coordinates to latlon as no basemap is defined!') def _get_zones(self): f_letter = np.vectorize(utm.latitude_to_zone_letter) f_number = np.vectorize(utm.latlon_to_zone_number) lat, lon = self.to_latlon() zone_numbers = f_number(lat,lon) zone_letters = f_letter(lat) if len(set(zip(zone_numbers.ravel(), zone_letters.ravel()))) !=1: print(f'Coordinates are spread across several UTM zones {[str(n) + l for n,l in set(zip(zone_numbers.ravel(), zone_letters.ravel()))]}') return zone_numbers, zone_letters
except: # Draw some map elements on the map m.drawcoastlines() m.drawstates() m.drawcountries() m.drawrivers(color='blue') print ("Normal map") #m.drawcoastlines( linewidth=0.1, color='k' ) # m.fillcontinents(color=land,lake_color=water,zorder=99) # ax.set_extent([lllon,urlon,lllat,urlat],crs=ccrs.PlateCarree()) # ax.add_feature(cfeature.NaturalEarthFeature('physical', 'land', '10m', edgecolor='face', facecolor=land),zorder=100) # # m.drawparallels([lllat,urlat], labels = [1,0,0,0], fontsize=10,linewidth=0,zorder=102) m.drawmeridians([lllon,urlon], labels = [0,0,0,1], fontsize=10,linewidth=0,zorder=102) data = ma.masked_less_equal(visual[npix:spix,wpix:epix],2) im=m.imshow(data,interpolation="nearest",origin="upper",cmap=cmapL,norm=norml,zorder=110) # interpolation="nearest",origin="upper", # print (lon,lat) # m.scatter(lon,lat,s=0.5,marker="o",zorder=110,edgecolors="g", facecolors="g")#,transform=ccrs.PlateCarree()) #, ax0.plot(lon ,lat ,color="g",marker="o",label="intitial",markersize=7,zorder=111) #fillstyle="none", #================ kx1= kx1lt[point] ky1= ky1lt[point] lat1 = south + 10.0 - res/2.0 - ky1*res lon1 = west + res/2.0 + kx1*res ax0.plot(lon1 ,lat1 ,color="r",marker="o",label="best-loc",markersize=7,zorder=112) #fillstyle="none", #================ kx2= kx2lt[point] ky2= ky2lt[point] if kx2 != -9999 and ky2 != -9999: lat2 = south + 10.0 - res/2.0 - ky2*res lon2 = west + res/2.0 + kx2*res
bwr_cmap = plt.get_cmap('bwr') cdict_new = bwr_cmap._segmentdata.copy() cdict_new['alpha'] = ((0.0, 1.0, 1.0), # (0.25,1.0, 1.0), (0.6, 0.4, 0.0), # (0.75,1.0, 1.0), (1.0, 1.0, 1.0)) blue_red1 = LinearSegmentedColormap('BlueRed1', cdict_new) # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ## Instantiate the Basemap - all subsequent images will be applied directly to the map. m = Basemap(llcrnrlon=lon0, llcrnrlat=lat0, urcrnrlon=lon1, urcrnrlat=lat1, resolution='l', lat_0=lat0, lon_0=lon0) # grab the openstreetmaps image osm_image = misc.imread('map.png') #plot it onto the map m.imshow(osm_image, extent=[lon0, lat0, lon1, lat1], origin='upper', aspect='auto') ## ## READ THE DATA: # read in the undocking data undocking_dataframe = pd.read_csv('2013-07-CitiBikeTripData.csv', usecols=[1,5,6], index_col=0, parse_dates=True) #read in the docking datax docking_dataframe_unsorted = pd.read_csv('2013-07-CitiBikeTripData.csv', usecols=[2,9,10], index_col=0, parse_dates=True) docking_dataframe = docking_dataframe_unsorted.sort_index() # find the first timestamp initial_start_date_undocking = undocking_dataframe.index[0] # ims will hold the series of images that make up the animation ims = [] # determine the number of frames in the animation
z_02 = griddata(xy1_igrid, z_igrid_02, (xi, yi), method='cubic') z_03 = griddata(xy1_igrid, z_igrid_03, (xi, yi), method='cubic') rgb_projected = np.zeros((1000, 1000, 3)) for i in np.arange(1000): for j in np.arange(1000): rgb_projected[i, j, 0] = z_01[i, j] rgb_projected[i, j, 1] = z_02[i, j] rgb_projected[i, j, 2] = z_03[i, j] #rgb_projected[ z > 1 ] = 1.0 #rgb_projected[ z < 0 ] = 0.0 whereAreNaNs = np.isnan(rgb_projected) rgb_projected[whereAreNaNs] = 0.75 img = m.imshow(np.rot90(np.fliplr(rgb_projected)), origin='lower') m.drawcoastlines() m.drawparallels(np.arange(-90., 120., 5.), color='k', labels=[True, False, False, False]) m.drawmeridians(np.arange(0., 420., 5.), color='k', labels=[False, False, False, True]) ax.set_xlabel("", fontsize=10) ax.set_ylabel("", fontsize=10) #boundingbox = [60.0, 29.0, 52.5, 45.0] lats = [52.5, 52.5, 60., 60.]
basemap_kws = dict(resolution='c', ax=the_ax) basemap_kws.update(project_channels['basemap_args']) bmap = Basemap(**basemap_kws) if index == 3: channel = project_channels['channels'][:, :, 0] - project_channels[ 'channels'][:, :, 1] chan_list.append('1-4') cmap = cmap_div cbar_label = 'reflectivity difference' elif index == 2: channel = project_channels['channels'][:, :, index] cbar_label = 'radiance W/m^2/sr/um' else: cbar_label = 'reflectance' channel = project_channels['channels'][:, :, index] col = bmap.imshow(channel, origin='upper', cmap=cmap, **limits[index]) bmap.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10, latmax=90) bmap.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10, latmax=90) bmap.drawcoastlines() _ = the_ax.set(title='vancouver chan {}'.format(chan_list[index])) colorbar = fig.colorbar(col, shrink=0.5, pad=0.05, extend='both', ax=the_ax)
chl_mat.mask = chl_mat == -999 m = Basemap(llcrnrlat=min(lat0),urcrnrlat=max(lat0),\ llcrnrlon=min(lon0),urcrnrlon=max(lon0), resolution='l') x, y = np.meshgrid(lon0, lat0) m.drawparallels(parallel_steps, labels=[1, 0, 0, 1], color='grey', linewidth=0.1) m.drawmeridians(meridian_steps, labels=[1, 0, 0, 1], color='grey', linewidth=0.1) m.drawcoastlines(linewidth=0.1) m.imshow(chl_mat,origin='upper', extent=[min(lon0), max(lon0), min(lat0), max(lat0)],\ norm=LogNorm(),cmap='rainbow',interpolation='nearest') clb = plt.colorbar(fraction=0.046, pad=0.05, orientation='horizontal') # clb.ax.set_xlabel('Absolute Density (counts)') # wtm ax = plt.subplot(2, 2, 2) ax.set_title('wtm(0 =< p1/(p1+p2) =< 1') current_cmap = plt.cm.get_cmap() current_cmap.set_bad(color='white') class_mask.mask = class_mask == -999 m = Basemap(llcrnrlat=min(lat0),urcrnrlat=max(lat0),\ llcrnrlon=min(lon0),urcrnrlon=max(lon0), resolution='l') x, y = np.meshgrid(lon0, lat0)
def map_haz(fig, plt, haz_map_file, sitelon, sitelat, **kwargs): ''' kwargs: shpfile: path to area source - is a list of files resolution: c (crude), l (low), i (intermediate), h (high), f (full) mbuffer: map buffer in degrees ''' from openquake.nrmllib.hazard.parsers import GMFScenarioParser from mpl_toolkits.basemap import Basemap from numpy import arange, array, log10, mean, mgrid, percentile from matplotlib.mlab import griddata from matplotlib import colors, colorbar, cm from os import path from mapping_tools import drawshapepoly, labelpolygon import shapefile # set kwargs drawshape = False res = 'c' mbuff = -0.3 keys = ['shapefile', 'resolution', 'mbuffer'] for key in keys: if key in kwargs: if key == 'shapefile': shpfile = kwargs[key] drawshape = True if key == 'resolution': res = kwargs[key] if key == 'mbuffer': mbuff = kwargs[key] gmfsp = GMFScenarioParser(haz_map_file).parse() metadata, values = parse_nrml_hazard_map(haz_map_file) hazvals = [] latlist = [] lonlist = [] for val in values: lonlist.append(val[0]) latlist.append(val[1]) hazvals.append(val[2]) # get map bounds llcrnrlat = min(latlist) - mbuff / 2. urcrnrlat = max(latlist) + mbuff / 2. llcrnrlon = min(lonlist) - mbuff urcrnrlon = max(lonlist) + mbuff lon_0 = mean([llcrnrlon, urcrnrlon]) lat_1 = percentile([llcrnrlat, urcrnrlat], 25) lat_2 = percentile([llcrnrlat, urcrnrlat], 75) m = Basemap(llcrnrlon=llcrnrlon,llcrnrlat=llcrnrlat, \ urcrnrlon=urcrnrlon,urcrnrlat=urcrnrlat, projection='lcc',lat_1=lat_1,lat_2=lat_2,lon_0=lon_0, resolution=res,area_thresh=1000.) m.drawcoastlines(linewidth=0.5, color='k') m.drawcountries() # draw parallels and meridians. m.drawparallels(arange(-90., 90., 1.), labels=[1, 0, 0, 0], fontsize=10, dashes=[2, 2], color='0.5', linewidth=0.5) m.drawmeridians(arange(0., 360., 1.), labels=[0, 0, 0, 1], fontsize=10, dashes=[2, 2], color='0.5', linewidth=0.5) # make regular grid N = 150j extent = (min(lonlist), max(lonlist), min(latlist), max(latlist)) xs, ys = mgrid[extent[0]:extent[1]:N, extent[2]:extent[3]:N] resampled = griddata(array(lonlist), array(latlist), log10(array(hazvals)), xs, ys) ############################################################################# # transform grid to basemap # get 1D lats and lons for map transform lons = ogrid[extent[0]:extent[1]:N] lats = ogrid[extent[2]:extent[3]:N] # transform to map projection if max(lonlist) - min(lonlist) < 1: transspace = 500 elif max(lonlist) - min(lonlist) < 5: transspace = 1000 elif max(lonlist) - min(lonlist) < 10: transspace = 2000 else: transspace = 5000 nx = int((m.xmax - m.xmin) / transspace) + 1 ny = int((m.ymax - m.ymin) / transspace) + 1 transhaz = m.transform_scalar(resampled.T, lons, lats, nx, ny) m.imshow(transhaz, cmap='Spectral_r', extent=extent, vmin=-2, vmax=log10(2.), zorder=0) # plot site xx, yy = m(sitelon, sitelat) plt.plot(xx, yy, '*', ms=20, mec='k', mew=2.0, mfc="None") # superimpose area source shapefile if drawshape == True: for shp in shpfile: sf = shapefile.Reader(shp) drawshapepoly(m, plt, sf, col='k', lw=1.5, polyline=True) labelpolygon(m, plt, sf, 'CODE', fsize=14) # set colourbar # set cb for final fig plt.gcf().subplots_adjust(bottom=0.1) cax = fig.add_axes([0.6, 0.05, 0.25, 0.02]) # setup colorbar axes. norm = colors.Normalize(vmin=-2, vmax=log10(2.)) cb = colorbar.ColorbarBase(cax, cmap=cm.Spectral_r, norm=norm, orientation='horizontal') # set cb labels #linticks = array([0.01, 0.03, 0.1, 0.3 ]) logticks = arange(-2, log10(2.), 0.25) cb.set_ticks(logticks) labels = [str('%0.2f' % 10**x) for x in logticks] cb.set_ticklabels(labels) # get map probabiltiy from filename mprob = path.split(haz_map_file)[-1].split('_')[-1].split('-')[0] probstr = str(int(float(mprob) * 100)) # set colourbar title if metadata['statistics'] == 'mean': titlestr = ''.join((metadata['imt'], ' ', metadata['sa_period'], ' s ', \ probstr,'% in ',metadata['investigation_time'][0:-2], \ ' Year Mean Hazard (g)')) #cb.set_ticklabels(labels) cb.set_label(titlestr, fontsize=12) return plt
import util import sys, os import d4PDF srcdir = '/home/utsumi/mnt/lab_tank/utsumi/bams2020/XX-HPB_NAT-100/6hr/pgrad/2010/01' idtime = datetime(2010,1,1,0) edtime = datetime(2010,1,31,18) ldtime = util.ret_lDTime(idtime, edtime, timedelta(hours=6)) ny,nx = 320,640 a1lat = d4PDF.Lat() a1lon = d4PDF.Lon() [[lllat,lllon],[urlat,urlon]] = [[-90,0],[90,360]] a2out = np.zeros([ny,nx], 'int32') a2zero= np.zeros([ny,nx], 'int32') for dtime in ldtime: year,mon,day,hour = dtime.timetuple()[:4] srcpath = srcdir + '/pgrad.2010012806.320x640' srcpath = srcdir + '/pgrad.%04d%02d%02d%02d.320x640'%(year,mon,day,hour) a2in = np.fromfile(srcpath,'float32').reshape(ny,nx) a2out = a2out + ma.masked_where(a2in>0, a2zero).filled(1).astype('int32') figmap = plt.figure() axmap = figmap.add_axes([0.1, 0.1, 0.8, 0.8]) M = Basemap( resolution="l", llcrnrlat=lllat, llcrnrlon=lllon, urcrnrlat=urlat, urcrnrlon=urlon, ax=axmap) im = M.imshow(ma.masked_equal(a2out,0), origin='lower',vmax=5) plt.colorbar(im) M.drawcoastlines() plt.savefig('/home/utsumi/temp/bams2020/temp.centers.png')
fi.write(str(anchor_positions_procrustes.tolist()) + "\n") fi.write(str(anchor_gt_positions.tolist()) + "\n") fi.write(str(pos_selfloc.tolist()) + "\n") fi.write(str(pos_selfloc_procrustes.tolist()) + "\n") # fi.write(str(tform.keys()) + "\n") # tform["rotation"] = tform["rotation"].tolist() # tform["translation"] = tform["translation"].tolist() # fi.write(str(tform.values()) + "\n") fi.write(str(stress) + "\n") fi.close() print "selfloc test results written to: \n" + results_file_selfloc if options.map: figure_map.canvas.set_window_title( args[0].split("/")[-1].split(".")[0] + "_map") basemap.imshow(img, interpolation='lanczos', origin='upper') i = 1 if options.crop_ict: ax.axis([85, 230, 48, 140]) basemap.drawmapscale(lon=6.06201, lat=50.77870, lon0=6.06201, lat0=50.77870, length=20, units='m', barstyle='fancy', fontsize=24, yoffset=1.2) else: basemap.drawmapscale(lon=bbox[0] - 0.1 * (bbox[0] - bbox[2]), lat=bbox[1] - 0.07 * (bbox[1] - bbox[3]),
def processing(path): """ Generates images from NetCDF files pathDir: root direcotry with "Data", "Output" and "Scripts" folders pathFile: path to NetCDF file to be manipulated outFolder: path to directory where the generated images should be saved Output: .png image file """ # Getting information from the file name ============================================================ # Search for the GOES-16 channel in the file name INPE_Band_ID = (path[path.find("S10635") + 6:path.find("_")]) # print(INPE_Band_ID) # Get the band number subtracting the value by 332 Band = int(INPE_Band_ID) - 332 # Create a GOES-16 Bands string array Wavelenghts = [ '[]', '[0.47 μm]', '[0.64 μm]', '[0.865 μm]', '[1.378 μm]', '[1.61 μm]', '[2.25 μm]', '[3.90 μm]', '[6.19 μm]', '[6.95 μm]', '[7.34 μm]', '[8.50 μm]', '[9.61 μm]', '[10.35 μm]', '[11.20 μm]', '[12.30 μm]', '[13.30 μm]' ] Band_Wavelenght = Wavelenghts[int(Band)] # Search for the Scan start in the file name Start = (path[path.find(INPE_Band_ID + "_") + 4:path.find(".nc")]) # Getting the date from the file name year = Start[0:4] month = Start[4:6] day = Start[6:8] date = day + "-" + month + "-" + year time = Start[8:10] + ":" + Start[ 10:12] + " UTC" # Time of the Start of the Scan # Get the unit based on the channel. If channels 1 trough 6 is Albedo. If channels 7 to 16 is BT. Unit = "Albedo (%)" # Choose a title for the plot Title = " GOES-16 ABI CMI Band " + str( Band) + " " + Band_Wavelenght + " " + Unit + " " + date + " " + time # Insert the institution name Institution = "CEPAGRI - UNICAMP" # Required libraries ================================================================================ # Open the file using the NetCDF4 library nc = Dataset(path) # Choose the visualization extent (min lon, min lat, max lon, max lat) extent = [-115.98, -55.98, -25.01, 34.98] min_lon = extent[0] max_lon = extent[2] min_lat = extent[1] max_lat = extent[3] # Get the latitudes lats = nc.variables['lat'][:] # Get the longitudes lons = nc.variables['lon'][:] # print (lats) # print (lons) # latitude lower and upper index latli = np.argmin(np.abs(lats - extent[1])) latui = np.argmin(np.abs(lats - extent[3])) # longitude lower and upper index lonli = np.argmin(np.abs(lons - extent[0])) lonui = np.argmin(np.abs(lons - extent[2])) # Extract the Brightness Temperature / Reflectance values from the NetCDF data = nc.variables['Band1'][latli:latui, lonli:lonui] # Flip the y axis, divede by 100 data = (np.flipud(data) / 100) # Define the size of the saved picture ============================================================== DPI = 150 ax = plt.figure(figsize=(2000 / float(DPI), 2000 / float(DPI)), frameon=True, dpi=DPI) #==================================================================================================== # Plot the Data ===================================================================================== # Create the basemap reference for the Rectangular Projection bmap = Basemap(llcrnrlon=extent[0], llcrnrlat=extent[1], urcrnrlon=extent[2], urcrnrlat=extent[3], epsg=4326) # Draw the countries and Brazilian states shapefiles bmap.readshapefile('/Scripts/GEONETCast/Shapefiles/BRA_adm1', 'BRA_adm1', linewidth=0.50, color='cyan') bmap.readshapefile( '/Scripts/GEONETCast/Shapefiles/ne_10m_admin_0_countries', 'ne_10m_admin_0_countries', linewidth=0.50, color='cyan') # Draw parallels and meridians bmap.drawparallels(np.arange(-90.0, 90.0, 5.0), linewidth=0.3, dashes=[4, 4], color='white', labels=[False, False, False, False], fmt='%g', labelstyle="+/-", xoffset=-0.80, yoffset=-1.00, size=7) bmap.drawmeridians(np.arange(0.0, 360.0, 5.0), linewidth=0.3, dashes=[4, 4], color='white', labels=[False, False, False, False], fmt='%g', labelstyle="+/-", xoffset=-0.80, yoffset=-1.00, size=7) # Converts a CPT file to be used in Python cpt = loadCPT( '/Scripts/GEONETCast/Colortables/Square Root Visible Enhancement.cpt') # Makes a linear interpolation cpt_convert = LinearSegmentedColormap('cpt', cpt) # Plot the GOES-16 channel with the converted CPT colors (you may alter the min and max to match your preference) bmap.imshow(data, origin='upper', cmap=cpt_convert, vmin=0, vmax=100) # Insert the colorbar at the bottom cb = bmap.colorbar(location='bottom', size='2%', pad='-3.5%', ticks=[20, 40, 60, 80]) cb.ax.set_xticklabels(['20', '40', '60', '80']) cb.outline.set_visible(False) # Remove the colorbar outline cb.ax.tick_params(width=0) # Remove the colorbar ticks cb.ax.xaxis.set_tick_params( pad=-14.5) # Put the colobar labels inside the colorbar cb.ax.tick_params( axis='x', colors='black', labelsize=8) # Change the color and size of the colorbar labels # Add a black rectangle in the bottom to insert the image description lon_difference = (extent[2] - extent[0]) # Max Lon - Min Lon currentAxis = plt.gca() currentAxis.add_patch( Rectangle((extent[0], extent[1]), lon_difference, lon_difference * 0.015, alpha=1, zorder=3, facecolor='black')) # Add the image description inside the black rectangle lat_difference = (extent[3] - extent[1]) # Max lat - Min lat plt.text(extent[0], extent[1] + lat_difference * 0.003, Title, horizontalalignment='left', color='white', size=10) plt.text(extent[2], extent[1] + lat_difference * 0.003, Institution, horizontalalignment='right', color='yellow', size=10) # Add logos / images to the plot logo_GNC = plt.imread('/Scripts/GEONETCast/Logos/GNC_Logo.png') logo_INPE = plt.imread('/Scripts/GEONETCast/Logos/INPE_Logo.png') logo_NOAA = plt.imread('/Scripts/GEONETCast/Logos/NOAA_Logo.png') logo_GOES = plt.imread('/Scripts/GEONETCast/Logos/GOES_Logo.png') logo_cepagri = plt.imread('/Scripts/GEONETCast/Logos/Logo_CEPAGRI.png') ax.figimage(logo_GNC, 20, 70, zorder=3, alpha=1, origin='upper') ax.figimage(logo_INPE, 90, 70, zorder=3, alpha=1, origin='upper') ax.figimage(logo_NOAA, 165, 70, zorder=3, alpha=1, origin='upper') ax.figimage(logo_GOES, 228, 70, zorder=3, alpha=1, origin='upper') ax.figimage(logo_cepagri, 326, 70, zorder=3, alpha=1, origin='upper') # Save the result # print('/Scripts/GEONETCast/Output/' + path[12:18] + '/INPE_G16_CH' + str(Band) + '_' + Start + '.png') plt.savefig('/Scripts/GEONETCast/Output/' + path[12:18] + '/INPE_G16_CH' + str(Band) + '_' + Start + '.png', dpi=DPI, bbox_inches='tight', pad_inches=0)