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 make_stations(network,latmin,latmax,lonmin,lonmax,dlat,dlon,plot=True,**kwargs):
head = kwargs.get('head','RM')
elev = kwargs.get('elev',0)
dep = kwargs.get('dep',0)
lats = np.arange(latmin,latmax+dlat,dlat)
lons = np.arange(lonmin,lonmax+dlon,dlon)
lats_pts,lons_pts = np.meshgrid(lats,lons)
if plot:
m = Basemap(projection='hammer',lon_0=0,resolution='l')
m.drawcoastlines()
m.drawmeridians(np.arange(0,351,10))
m.drawparallels(np.arange(-80,81,10))
lons_pts2,lats_pts2 = m(lons_pts,lats_pts)
m.scatter(lons_pts2,lats_pts2)
plt.show()
f = open('STATIONS','w')
print 'total number of stations : ',len(lats_pts)
st = 1
for i in range(0,len(lats)):
for j in range(0,len(lons)):
f.write('{}{:04d} {} {:5.2f} {:5.2f} {:5.2f} {:5.2f}'.format(head,st,network,lats[i],lons[j],elev,dep)+'\n')
st += 1
def plot_pnts(source, ra_0, dec_0, FOV='fullsky', grid_size=15.):
ra, dec = np.genfromtxt(source, usecols=(0, 1), unpack=True)
ra *= 15.
sky = Basemap(projection='ortho', lon_0=-ra_0, lat_0=dec_0, celestial=True)
if FOV == 'fullsky':
sky.drawmeridians(np.arange(0., 360., grid_size))
sky.drawparallels(np.arange(90, -90, -grid_size))
sky.drawmapboundary(fill_color='White')
catx, caty = sky(ra, dec)
sky.scatter(catx, caty, 3, marker='o', color='Black')
elif isinstance(FOV, float):
format_label = lambda deg: '{0:2.0f}h{1:2.0f}m'\
.format(np.floor(deg / 15.), np.remainder(deg, 15.) * 60. / 15.)
cnreq = np.array([[ra_0 + FOV / 2., dec_0 - FOV / 2.],
[ra_0 - FOV / 2., dec_0 + FOV / 2.]])
cnrxy = np.array(sky(cnreq[:, 0], cnreq[:, 1])).T
cenxy = np.array(sky(ra_0, dec_0))
m = Basemap(projection='ortho', lon_0=-ra_0, lat_0=dec_0,
celestial=True, llcrnrx=cnrxy[0, 0]-cenxy[0],
llcrnry=cnrxy[0, 1]-cenxy[1], urcrnrx=cnrxy[1, 0]-cenxy[0],
urcrnry=cnrxy[1, 1]-cenxy[1])
m.drawmeridians(np.arange(cnreq[0, 0], cnreq[1, 0], -grid_size),
labels=[0, 0, 0, 1], fmt=format_label)
m.drawparallels(np.arange(cnreq[0, 1], cnreq[1, 1], grid_size),
labels=[1, 0, 0, 0])
m.drawmapboundary(fill_color='White')
catx, caty = m(ra, dec)
m.scatter(catx, caty, 3, marker='o', color='Black')
def example_1():
orig_file = '/tmp/comp-tempo/20101206-EUR-L2P_GHRSST-SSTsubskin-AVHRR_METOP_A-eumetsat_sstmgr_metop02_20101206_000403-v01.7-fv01.0.nc'
orig_dset = Dataset(orig_file, 'a')
o_lat = orig_dset.variables['lat'][:].ravel()
o_lon = orig_dset.variables['lon'][:].ravel()
print(np.mean(o_lon))
# lon_0 is the central longitude of the projection.
# resolution = 'l' means use low resolution coastlines.
# optional parameter 'satellite_height' may be used to
# specify height of orbit above earth (default 35,786 km).
m = Basemap(projection='geos',lon_0=133,resolution='l')
m.drawcoastlines()
m.fillcontinents(color='coral',lake_color='aqua')
# draw parallels and meridians.
m.drawparallels(np.arange(-90.,120.,30.))
m.drawmeridians(np.arange(0.,420.,60.))
m.drawmapboundary(fill_color='aqua')
x, y = m(o_lat[0:100] , o_lon[0:100])
#m.plot(x, y)
plt.title("Full Disk Geostationary Projection")
#plt.savefig('geos_full.png')
plt.show()
def Map(self):
m = Basemap(projection='cyl', # stere, tmerc, lcc
lat_0=39.828127, lon_0=-98.579404,
urcrnrlon=-62.208289, urcrnrlat=51.342619,
llcrnrlon=-128.936426, llcrnrlat=19.06875)
m.drawcoastlines() # draw coastlines
m.drawmapboundary() # draw a line around the map region
m.drawparallels(np.arange(-90., 120., 30.), labels=[1, 0, 0, 0]) # draw parallels
m.drawmeridians(np.arange(0., 420., 60.), labels=[0, 0, 0, 1]) # draw meridians
m.drawstates()
m.drawcountries()
lon = list()
lon.append(-80.633333)
lon.append(-74.364684)
lon.append(-75.387778)
lon.append(-84.253333)
lat = list()
lat.append(28.116667)
lat.append(40.715622)
lat.append(40.043889)
lat.append(30.455)
m.scatter(lon, lat, latlon=True, c=np.random.rand(3))
#m.pcolor(lon, lat, latlon=True)
plt.title('United States Fair Market Rent') # add a title
plt.show()
def ResearchRegion_surface():
"""
在地图上画出柱表面混合比图
:return:
"""
fig = plt.figure(figsize=(11, 8), facecolor="white")
# data = np.loadtxt('seasonAvr_data/SurfaceMixingRatio/1_seasonAvr.txt')
data = np.loadtxt("allYearAvr_data/SurfaceMixingRatio/allYearAvr.txt")
arr = np.zeros((180, 360))
for i in range(180):
arr[i, :] = data[179 - i, :]
longitude = np.loadtxt("lonlat_data/longitude.txt")
latitude = np.loadtxt("lonlat_data/latitude.txt")
m = Basemap(llcrnrlon=70, llcrnrlat=15, urcrnrlon=138, urcrnrlat=55, projection="mill", resolution="h")
m.drawparallels(np.arange(5.5, 90.5, 1.0), color="w", linewidth=0.5, dashes=[1, 1], labels=[0, 0, 0, 0])
m.drawmeridians(np.arange(60.5, 181.5, 1.0), color="w", linewidth=0.5, dashes=[1, 1], labels=[0, 0, 0, 0])
m.drawmapboundary(fill_color="0.3")
m.readshapefile("shp/CHINA", "CHINA", drawbounds=1, color="black")
topo = maskoceans(longitude, latitude, arr)
im = m.pcolormesh(longitude, latitude, topo, shading="flat", cmap=plt.cm.jet, latlon=True, vmin=0, vmax=500)
m.drawlsmask(ocean_color="w", lsmask=0)
cbar = m.colorbar()
cbar.ax.set_ylabel("SurfaceMixingRatio", color="black", fontsize="14", rotation=90)
plt.show()
def individual_ocean_map(eof = '1', phase = 'lanina', showplot = True):
### This function combines several others to make a map
patterns, lats, lons, lams, pcs = combine_regions(phase = phase)
data, lns, lts = create_full_map_individual(patterns, lats, lons, eof = eof)
from numpy import linspace
fig = plt.figure()
ax = fig.add_subplot(111)
m = Basemap(ax = ax, projection = 'robin', lon_0 = 180, resolution = 'i')
m.drawmapboundary(fill_color='aqua')
m.drawcoastlines(linewidth = 0.25)
m.drawcountries()
m.fillcontinents(color='green',lake_color='aqua')
parallels = np.linspace(m.llcrnrlat, m.urcrnrlat, 4)
meridians = np.linspace(m.llcrnrlon, m.urcrnrlon, 4)
m.drawparallels(parallels, linewidth = 1, labels = [0,0,0,0])
m.drawmeridians(meridians, linewidth = 1, labels = [0,0,0,0])
cmap = cm.RdBu_r
im = m.pcolormesh(lns,lts,data, vmin = data[~isnan(data)].min(), \
vmax=data[~isnan(data)].max(), cmap = cmap, latlon=True)
cb = m.colorbar(im,'bottom', size="5%", pad="2%")
if showplot:
plt.show()
return
return fig, ax, m
def map_interiorAK(
width=1800000,
height=1200000,
water='lightskyblue',
earth='snow',
resolution='i'):
"""
Albers Equal Area map of interior Alaska, with some overridable presets.
"""
bmap = Basemap(
width=width,
height=height,
resolution=resolution,
projection='aea',
lat_1=55., lat_2=75., lat_0=65., lon_0=-150.)
bmap.drawcoastlines()
bmap.drawrivers(color=water)
bmap.drawcountries()
bmap.fillcontinents(lake_color=water, color=earth)
# labels = [left,right,top,bottom]
bmap.drawmeridians(
np.arange(-180, 180, 10), labels=[False, False, False, 1])
bmap.drawparallels(
np.arange(0, 80, 5), labels=[1, 1, False, False])
bmap.drawmapboundary(fill_color=water)
return bmap
def bb_map(lons, lats, projection='merc', resolution='i', drawparallels=True, drawmeridians=True, ax=plt.gca()): """ USAGE ----- m = bb_map(lons, lats, **kwargs) Returns a Basemap instance with lon,lat bounding limits inferred from the input arrays `lons`,`lats`. Coastlines, countries, states, parallels and meridians are drawn, and continents are filled. """ lons,lats = map(np.asanyarray, (lons,lats)) lonmin,lonmax = lons.min(),lons.max() latmin,latmax = lats.min(),lats.max() m = Basemap(llcrnrlon=lonmin, urcrnrlon=lonmax, llcrnrlat=latmin, urcrnrlat=latmax, projection=projection, resolution=resolution, ax=ax) plt.ioff() # Avoid showing the figure. m.fillcontinents(color='0.9', zorder=9) m.drawcoastlines(zorder=10) m.drawstates(zorder=10) m.drawcountries(linewidth=2.0, zorder=10) m.drawmapboundary(zorder=9999) if drawmeridians: m.drawmeridians(np.arange(np.floor(lonmin), np.ceil(lonmax), 1), linewidth=0.15, labels=[1, 0, 1, 0], zorder=12) if drawparallels: m.drawparallels(np.arange(np.floor(latmin), np.ceil(latmax), 1), linewidth=0.15, labels=[1, 0, 0, 0], zorder=12) plt.ion() return m
def sstMap(nipaPhase, phase = 'allyears', field = 'sst', fig = None, ax = None, monte = False):
from numpy import linspace
if fig == None:
fig = plt.figure()
ax = fig.add_subplot(111)
m = Basemap(ax = ax, projection = 'robin', lon_0 = 270, resolution = 'i')
m.drawmapboundary(fill_color='aqua')
m.drawcoastlines(linewidth = 0.25)
m.drawcountries()
m.fillcontinents(color='green',lake_color='aqua')
parallels = np.linspace(m.llcrnrlat, m.urcrnrlat, 4)
meridians = np.linspace(m.llcrnrlon, m.urcrnrlon, 4)
m.drawparallels(parallels, linewidth = 1, labels = [0,0,0,0])
m.drawmeridians(meridians, linewidth = 1, labels = [0,0,0,0])
lons = nipaPhase.lon[field]
lats = nipaPhase.lat[field]
if monte:
data = nipaPhase.monte_grid[phase]
levels = linspace(0, data.max(), data.max())
cmap = cm.Reds
else:
data = nipaPhase.corr_grid[field][phase]
levels = linspace(-0.8,0.8,9)
cmap = cm.RdBu
lons, lats = np.meshgrid(lons,lats)
im1 = m.pcolormesh(lons,lats,data, vmin = np.min(levels), \
vmax=np.max(levels), cmap = cmap, latlon=True)
cb = m.colorbar(im1,'bottom', size="5%", pad="2%")
ax.set_title('%s, %s' % (phase, field))
return fig, ax, m
def regional_subplot(lons, lats, data, extreme, cent_lat, cent_lon, min_lon, max_lon, min_lat, max_lat, parallels, meridians, cmap, vmin, title,
plot_number, coastline_color, background_color):
ax = plt.subplot(plot_number)
ax.set_axis_bgcolor(background_color)
ETA_m = haversine_distance((min_lat, cent_lon), (max_lat, cent_lon), True)
XI_m = haversine_distance((min_lat, min_lon), (max_lat, max_lon),True)
map = Basemap(height=ETA_m, width=XI_m,
resolution='l', area_thresh=1000., projection='omerc', \
lon_0=cent_lon, lat_0=cent_lat, lon_2=cent_lon, lat_2=min_lat, lon_1=cent_lon, lat_1=max_lat)
map.drawcoastlines(color=coastline_color)
# labels = [left,right,top,bottom]
map.drawparallels(parallels, labels=[True, False, False, False])
map.drawmeridians(meridians, labels=[False, False, False, True])
cs = map.contourf(lons, lats, data, levels=numpy.linspace((-1 * extreme), extreme, 101), cmap=cmap,
vmin=vmin, vmax=extreme, extend='both', latlon=True)
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="2%", pad=0.05)
plt.colorbar(cs, cax=cax, ticks=[-1 * extreme, 0, extreme], extend='both')
ax.set_title(title)
return ax
def plot_map(lons, lats, c, legend_label, projection='mill',
llcrnrlat=-80, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180, resolution='i'):
''' Optional Arguments: projection - map projection, default set as 'mill'
llcrnrlat - lower left corner latitude value, default is -80
urcrnrlat - upper right corner latitude value, default is 90
llcrnrlon - lower left corner longitude value, default is -180
urcrnrlon - upper right corner longitude value, default is 180
resolution - the resolution of the plot, default is 'i'
Required Arguments: lons - list of longitude values to be plotted
lats - list of latitude values to be plotted
c - the color of the points to be plotted
legend_label - how this set of points will be labeled on the legend
Returns: m - a basemap object defined by input bounds with input points included '''
# Creates a basic plot of a series of lat,lon points over a defined region
m = Basemap(projection=projection, llcrnrlat=llcrnrlat, urcrnrlat=urcrnrlat,
llcrnrlon=llcrnrlon, urcrnrlon=urcrnrlon, resolution=resolution)
m.drawcoastlines()
m.drawmapboundary()
m.drawcountries()
m.etopo()
m.drawmeridians(np.arange(llcrnrlon, urcrnrlon, 5), labels=[0,0,0,1], fontsize=10)
m.drawparallels(np.arange(llcrnrlat, urcrnrlat, 5), labels=[1,0,0,0], fontsize=10)
x,y = m(lons, lats)
m.scatter(x, y, color=c, label=legend_label, marker='o', edgecolor='none', s=10)
return m
def nepal_basemap(prams = nepal_ETAS_prams, fnum=0, map_res='i', **kwargs):
# hours_after: upper time limit for aftershocks to plot.
prams.update(kwargs)
#
lons_nepal = [83., 87.]
lats_nepal = [26., 30.]
todt=prams.get('todt', None)
catlen=prams.get('catlen', 5.*365.)
lons=prams['lons']
lats=prams['lats']
mc = prams['mc']
#
if todt==None: todt = dtm.datetime.now(pytz.timezone('UTC'))
dt0 = todt - dtm.timedelta(days=catlen)
#
plt.figure(fnum)
plt.clf()
ax1=plt.gca()
cntr = [.5*(lons[0]+lons[1]), .5*(lats[0]+lats[1])]
#
cm=Basemap(llcrnrlon=lons_nepal[0], llcrnrlat=lats_nepal[0], urcrnrlon=lons_nepal[1], urcrnrlat=lats_nepal[1], resolution=map_res, projection='cyl', lon_0=cntr[0], lat_0=cntr[1])
cm.drawcoastlines(color='gray', zorder=1)
cm.drawcountries(color='gray', zorder=1)
cm.drawstates(color='gray', zorder=1)
cm.drawrivers(color='gray', zorder=1)
cm.fillcontinents(color='beige', zorder=0)
#
cm.drawmeridians(list(range(int(lons[0]), int(lons[1]))), color='k', labels=[0,0,1,1])
cm.drawparallels(list(range(int(lats[0]), int(lats[1]))), color='k', labels=[1, 1, 0, 0])
#
return cm
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 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 drawNPole(self):
#No es muy ortodoxo dibujar dentro de la clase
my_map = Basemap(projection='npstere',boundinglat=50,lon_0=270,resolution='h', round=True)
my_map.drawcoastlines()
my_map.drawcountries()
my_map.fillcontinents(color='coral')
my_map.drawmapboundary()
#print "tamano:", len(self)
for measure in self:
x,y = my_map(measure.getLon(), measure.getLat())
print measure.getLat(), measure.getLon(), measure.getSic()
color = 'go'
#print "color->", measure.getSic()
if measure.getSic()>0 and measure.getSic()<=0.2:
color = 'go'
elif measure.getSic()>0.2 and measure.getSic()<=0.5:
color = 'yo'
else:
color = 'ro'
my_map.plot(y, x, color, markersize=12)
my_map.drawmeridians(np.arange(0, 360, 30))
my_map.drawparallels(np.arange(-90, 90, 30))
#m.hexbin(x1,y1, C=sic[beam],gridsize=len(sic[beam]),cmap=plt.cm.jet)
plt.gcf().set_size_inches(18,10)
plt.show()
def plot_grid2D(lons, lats, tec_grid2D, datetime, title_label = ''):
LATS, LONS = np.meshgrid(lats, lons)
m = Basemap(llcrnrlon=-180,
llcrnrlat=-55,
urcrnrlon=180,
urcrnrlat=75,
projection='merc',
area_thresh=1000,
resolution='i')
m.drawstates()
m.drawcountries()
m.drawcoastlines()
parallels = np.arange(-90,90,20)
m.drawparallels(parallels,labels=[True,False,False,True])
meridians = np.arange(0,360,40)
m.drawmeridians(meridians,labels=[True,False,False,True])
m.scatter(LONS, LATS, c=tec_grid2D, latlon = True, linewidths=0, s=5)
m.colorbar()
plt.title('%s\n%s' % (title_label, datetime.isoformat(' ')))
def run(FILE_NAME):
with h5py.File(FILE_NAME, mode='r') as f:
name = '/Grid/IRprecipitation'
data = f[name][:]
units = f[name].attrs['units']
_FillValue = f[name].attrs['_FillValue']
data[data == _FillValue] = np.nan
data = np.ma.masked_where(np.isnan(data), data)
# Get the geolocation data
latitude = f['/Grid/lat'][:]
longitude = f['/Grid/lon'][:]
m = Basemap(projection='cyl', resolution='l',
llcrnrlat=-90, urcrnrlat=90,
llcrnrlon=-180, urcrnrlon=180)
m.drawcoastlines(linewidth=0.5)
m.drawparallels(np.arange(-90, 91, 45))
m.drawmeridians(np.arange(-180, 180, 45), labels=[True,False,False,True])
m.pcolormesh(longitude, latitude, data.T, latlon=True)
cb = m.colorbar()
cb.set_label(units)
basename = os.path.basename(FILE_NAME)
plt.title('{0}\n{1}'.format(basename, name))
fig = plt.gcf()
# plt.show()
pngfile = "{0}.py.png".format(basename)
fig.savefig(pngfile)
def 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 vec_plot_south_america(lons, lats, sa_mask, data_x, data_y, ax=None):
if ax == None:
ax = plt.gca()
#print(sa_mask.shape)
#print(data_x.shape)
#print(data_y.shape)
#data_x_masked = np.ma.array(data_x, mask=sa_mask)
#data_y_masked = np.ma.array(data_y, mask=sa_mask)
plot_lons, plot_x_data = extend_data(lons, lats, data_x)
plot_lons, plot_y_data = extend_data(lons, lats, data_y)
lons, lats = np.meshgrid(plot_lons, lats)
m = Basemap(ax=ax, projection='cyl', resolution='c', llcrnrlat=-60, urcrnrlat=15, llcrnrlon=-85, urcrnrlon=-32)
x, y = m(lons, lats)
mag = np.sqrt(plot_x_data**2 + plot_y_data**2)
vmin, vmax = mag.min(), mag.max()
m.contourf(x[:-1,:], y[:-1,:], mag, ax=ax)
#m.pcolormesh(x, y, mag, vmin=vmin, vmax=vmax, ax=ax)
m.quiver(x, y, plot_x_data, plot_y_data, scale=40, ax=ax)
m.drawcoastlines(ax=ax)
m.drawparallels(np.arange(-60.,15.,10.), labels=[1, 0, 0, 0], fontsize=10, ax=ax)
m.drawmeridians(np.arange(-90.,-30.,10.), labels=[0, 0, 0, 1], fontsize=10, ax=ax)
m.colorbar(location='right', pad='5%', ax=ax)
plt.show()
def vec_plot_polar(lons, lats, data_x, data_y, pole, ax=None):
if ax == None:
ax = plt.gca()
plot_lons, plot_x_data = extend_data(lons, lats, data_x)
plot_lons, plot_y_data = extend_data(lons, lats, data_y)
lons, lats = np.meshgrid(plot_lons, lats)
if pole == 'N':
m = Basemap(ax=ax, resolution='c',projection='stere',lat_0=90.,lon_0=0, width=12000000,height=8000000)
elif pole == 'S':
m = Basemap(ax=ax, resolution='c',projection='stere',lat_0=-90.,lon_0=0, width=12000000,height=8000000)
x, y = m(lons, lats)
mag = np.sqrt(plot_x_data**2 + plot_y_data**2)
vmin, vmax = mag.min(), mag.max()
m.contourf(x[:-1,:], y[:-1,:], mag, ax=ax)
#m.pcolormesh(x, y, mag, vmin=vmin, vmax=vmax, ax=ax)
skip = 5
m.quiver(x[::5, ::5], y[::5, ::5], plot_x_data[::5, ::5], plot_y_data[::5, ::5], scale=50, ax=ax)
m.drawcoastlines(ax=ax)
m.drawparallels(np.arange(-60.,15.,10.), labels=[1, 0, 0, 0], fontsize=10, ax=ax)
m.drawmeridians(np.arange(-180.,180.,10.), fontsize=10, ax=ax)
m.colorbar(location='right', pad='5%', ax=ax)
plt.show()
def plot_on_earth(lons, lats, data, vmin=-4, vmax=12, cbar_loc='left', cbar_ticks=None):
#import ipdb; ipdb.set_trace()
#if ax == None:
#ax = plt.gca()
plot_lons, plot_data = extend_data(lons, lats, data)
lons, lats = np.meshgrid(plot_lons, lats)
m = Basemap(projection='cyl', resolution='c', llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180)
x, y = m(lons, lats)
m.pcolormesh(x, y, plot_data, vmin=vmin, vmax=vmax)
#m.pcolormesh(x, y, plot_data)
m.drawcoastlines()
if cbar_loc == 'left':
p_labels = [0, 1, 0, 0]
else:
p_labels = [1, 0, 0, 0]
m.drawparallels(np.arange(-90.,90.1,45.), labels=p_labels, fontsize=10)
m.drawmeridians(np.arange(-180.,180.,60.), labels=[0, 0, 0, 1], fontsize=10)
#import ipdb; ipdb.set_trace()
if cbar_ticks == None:
cbar = m.colorbar(location=cbar_loc, pad='7%')
else:
cbar = m.colorbar(location=cbar_loc, pad='7%', ticks=cbar_ticks)
if cbar_loc == 'left':
cbar.ax.xaxis.get_offset_text().set_position((10,0))
def plot_ICON_clt(ICON_data_dict):
"This function gets ICON data and plots corresponding satellite pictures."
# Import and create basemap for plotting countries and coastlines
from mpl_toolkits.basemap import Basemap
# Create well formatted time_string
time_string = datetime.fromtimestamp(int(unix_time_in)).strftime('%Y-%m-%d-%H-%M')
# Plotting temperature data
plt.figure()
# Plot contourf plot with lat/lon regridded ICON data
cmap_cloud = plt.cm.gray
levels_cloud = np.arange(0,101,10)
plt.contourf(ICON_data_dict["ICON_X_mesh"], ICON_data_dict["ICON_Y_mesh"], ICON_data_dict["ICON_clt"], levels=levels_cloud, cmap=cmap_cloud)
plt.colorbar()
# Plot map data
map = Basemap(llcrnrlon=4.0,llcrnrlat=47.0,urcrnrlon=15.0,urcrnrlat=55.0,
resolution='i')
map.drawcoastlines()
map.drawcountries()
lat_ticks = [55.0,53.0,51.0,49.0,47.0]
map.drawparallels(lat_ticks, labels=[1,0,0,0], linewidth=0.0)
lon_ticks = [4.0,6.0,8.0,10.0,12.0,14.0]
map.drawmeridians(lon_ticks, labels=[0,0,0,1], linewidth=0.0)
# Save plot and show it
plt.savefig(output_path + 'TotalCloudCover_' + time_string + '.png')
def Scatter(data, lons, lats, min, max, cmp, tit, unit, figdir, filename):
# Prepare for drawing
# ny, nx = (50, 116)
# draw Chile Basemap with lambert projection at normal x, y settings
m = Basemap(
llcrnrlon=-78,
llcrnrlat=-56,
urcrnrlon=-66,
urcrnrlat=-17,
projection="cyl",
fix_aspect=False,
lat_1=-43,
lat_2=-30,
lon_0=-72,
) # projection='lcc'
# draw boundaries
m.drawcoastlines()
m.drawcountries(linewidth=2)
m.drawstates()
m.drawparallels(arange(-60, -15, 15), labels=[1, 0, 0, 0]) # only left ytick
m.drawmeridians(arange(-80, -60, 5), labels=[0, 0, 0, 1]) # only bottom xtick
# map data with lon and lat position
im = m.scatter(lons, lats, 30, marker="o", c=data, vmin=min, vmax=max, latlon=True, cmap=cmp)
cb = m.colorbar(im, pad="10%")
plt.title(tit, fontsize=20)
plt.xlabel(unit, labelpad=50)
# savefig('%s%s' % (figdir, filename))
plt.show()
def show(self, proj='moll', lon_0=180, tmap=None, coord=None):
from mpl_toolkits.basemap import Basemap
import pylab as plt
import resources.figures as figures
figures.set_fancy()
if coord==None:
ra = np.rad2deg(self.grid['points'][:,0])
dec = np.rad2deg(self.grid['points'][:,1])
else:
ra = np.rad2deg(coord[:,0])
dec = np.rad2deg(coord[:,1])
fig = plt.figure()
m = Basemap(projection=proj,lon_0=lon_0)#,celestial=True) # celestial=True inverses alpha (East towards the right)
m.drawparallels(np.arange(-60.,90.,30.),labels=[1,0,0,0])
m.drawmeridians(np.arange(0.,360.,30.))
ra__ = np.arange(0., 360., 30.)
x, y = m(ra__,ra__*0)
for x,y,t in zip(x,y,ra__):
plt.text(x, y, figures.format_degree(t), color='black', ha='center', weight='black', size='small') ##93c6ed
if tmap==None:
m.scatter(ra,dec,latlon=True,marker='x',s=20,cmap=plt.cm.binary)
else:
m.scatter(ra,dec,c=tmap,latlon=True,marker='x',s=20,cmap=plt.cm.binary)
plt.show()
def get_catalog_map(lats=None, lons=None, eq_cat=[], map_res='i', map_projection='cyl', fignum=0, ax=None, do_clf=True):
#
if lats==None: lats = [31., 42.]
if lons==None: lons = [-125., -114.]
#
if fignum!=None: plt.figure(fignum)
if do_clf: plt.clf()
if ax==None: ax=plt.gca()
#
cm = Basemap(llcrnrlon=lons[0], llcrnrlat=lats[0], urcrnrlon=lons[1], urcrnrlat=lats[1], resolution=map_res, projection=map_projection, lon_0=numpy.mean(lons), lat_0=numpy.mean(lats), ax=ax)
cm.drawcoastlines(color='gray', zorder=1)
cm.drawcountries(color='gray', zorder=1)
cm.drawstates(color='gray', zorder=1)
cm.drawrivers(color='gray', zorder=1)
cm.fillcontinents(color='beige', zorder=0)
# drawlsmask(land_color='0.8', ocean_color='w', lsmask=None, lsmask_lons=None, lsmask_lats=None, lakes=True, resolution='l', grid=5, **kwargs)
#cm.drawlsmask(land_color='0.8', ocean_color='c', lsmask=None, lsmask_lons=None, lsmask_lats=None, lakes=True, resolution=mapres, grid=5)
print("lat, lon ranges: ", lats, lons)
cm.drawmeridians(list(range(int(lons[0]), int(lons[1]))), color='k', labels=[0,0,1,1])
cm.drawparallels(list(range(int(lats[0]), int(lats[1]))), color='k', labels=[1, 1, 0, 0])
#
if eq_cat!=None:
# can we also assign sizes dynamically, like colors?
if hasattr(eq_cat, 'dtype'):
# it's a recrray:
X,Y = cm(eq_cat['lon'], eq_cat['lat'])
else:
# it's probably a list... though we should check for dicts, etc.
X,Y = cm([rw[2] for rw in eq_cat], [rw[1] for rw in eq_cat])
#
cm.plot(X,Y, '.')
#
return cm
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(self,key='Re'):
"""
Create a plot of a variable over the ORACLES study area.
Parameters
----------
key : string
See names for available datasets to plot.
clf : boolean
If True, clear off pre-existing figure. If False, plot over pre-existing figure.
Modification history
--------------------
Written: Michael Diamond, 08/16/2016, Seattle, WA
Modified: Michael Diamond, 08/21/2016, Seattle, WA
-Added ORACLES routine flight plan, Walvis Bay (orange), and Ascension Island
Modified: Michael Diamond, 09/02/2016, Swakopmund, Namibia
-Updated flihgt track
"""
plt.clf()
size = 16
font = 'Arial'
m = Basemap(llcrnrlon=self.lon.min(),llcrnrlat=self.lat.min(),urcrnrlon=self.lon.max(),\
urcrnrlat=self.lat.max(),projection='merc',resolution='i')
m.drawparallels(np.arange(-180,180,5),labels=[1,0,0,0],fontsize=size,fontname=font)
m.drawmeridians(np.arange(0,360,5),labels=[1,1,0,1],fontsize=size,fontname=font)
m.drawmapboundary(linewidth=1.5)
m.drawcoastlines()
m.drawcountries()
if key == 'Pbot' or key == 'Ptop' or key == 'Nd' or key == 'DZ':
m.drawmapboundary(fill_color='steelblue')
m.fillcontinents(color='floralwhite',lake_color='steelblue',zorder=0)
else: m.fillcontinents('k',zorder=0)
if key == 'Nd':
m.pcolormesh(self.lon,self.lat,self.ds['%s' % key],cmap=self.colors['%s' % key],\
latlon=True,norm = LogNorm(vmin=self.v['%s' % key][0],vmax=self.v['%s' % key][1]))
elif key == 'Zbf' or key == 'Ztf':
levels = [0,250,500,750,1000,1250,1500,1750,2000,2500,3000,3500,4000,5000,6000,7000,8000,9000,10000]
m.contourf(self.lon,self.lat,self.ds['%s' % key],levels=levels,\
cmap=self.colors['%s' % key],latlon=True,extend='max')
elif key == 'DZ':
levels = [0,500,1000,1500,2000,2500,3000,3500,4000,4500,5000,5500,6000,6500,7000]
m.contourf(self.lon,self.lat,self.ds['%s' % key],levels=levels,\
cmap=self.colors['%s' % key],latlon=True,extend='max')
else:
m.pcolormesh(self.lon,self.lat,self.ds['%s' % key],cmap=self.colors['%s' % key],\
latlon=True,vmin=self.v['%s' % key][0],vmax=self.v['%s' % key][1])
cbar = m.colorbar()
cbar.ax.tick_params(labelsize=size-2)
cbar.set_label('[%s]' % self.units['%s' % key],fontsize=size,fontname=font)
if key == 'Pbot' or key == 'Ptop': cbar.ax.invert_yaxis()
m.scatter(14.5247,-22.9390,s=250,c='orange',marker='D',latlon=True)
m.scatter(-14.3559,-7.9467,s=375,c='c',marker='*',latlon=True)
m.scatter(-5.7089,-15.9650,s=375,c='chartreuse',marker='*',latlon=True)
m.plot([14.5247,13,0],[-22.9390,-23,-10],c='w',linewidth=5,linestyle='dashed',latlon=True)
m.plot([14.5247,13,0],[-22.9390,-23,-10],c='k',linewidth=3,linestyle='dashed',latlon=True)
plt.title('%s from MSG SEVIRI on %s/%s/%s at %s UTC' % \
(self.names['%s' % key],self.month,self.day,self.year,self.time),fontsize=size+4,fontname=font)
plt.show()
def ww3_plot(fname,xlim=False,ylim=False,res='c'):
'''
ex.:
f='WW3_data/2012/multi_1.glo_30m.dp.201201.grb2'
swanu.ww3_plot(f,xlim=[-100,-80],ylim=[20,32],res='i')
'''
from mpl_toolkits.basemap import Basemap
import pylab as pl
f=pygrib.open(fname)
lat,lon=f.message(1).latlons()
lon[lon>180]=lon[lon>180]-360.
if not xlim: xlim=-180,180
if not ylim: ylim=-90,90
m = Basemap(projection='cyl',llcrnrlat=ylim[0],urcrnrlat=ylim[1],
llcrnrlon=xlim[0],urcrnrlon=xlim[1],resolution=res)
m.drawcoastlines()
m.fillcontinents(color='#cccccc',lake_color='w')
# draw parallels and meridians.
m.drawparallels(np.arange(-90.,91.,30.))
m.drawmeridians(np.arange(-180.,181.,60.))
x,y=m(lon,lat)
pl.plot(x,y,'b.',ms=.5)
pl.show()
def vec_plot_on_earth(lons, lats, x_data, y_data, vmin=-4, vmax=12, ax=None):
if ax == None:
ax = plt.gca()
plot_lons, plot_x_data = extend_data(lons, lats, x_data)
plot_lons, plot_y_data = extend_data(lons, lats, y_data)
lons, lats = np.meshgrid(plot_lons, lats)
m = Basemap(ax=ax, projection='cyl', resolution='c', llcrnrlat=-90, urcrnrlat=90, llcrnrlon=-180, urcrnrlon=180)
x, y = m(lons, lats)
mag = np.sqrt(plot_x_data**2 + plot_y_data**2)
vmin, vmax = mag.min(), mag.max()
m.contourf(x[:-1,:], y[:-1,:], mag, ax=ax)
#m.pcolormesh(x, y, mag, vmin=vmin, vmax=vmax)
#m.quiver(x, y, plot_x_data, plot_y_data)
skip = 5
m.quiver(x[::skip, ::skip], y[::skip, ::skip], plot_x_data[::skip, ::skip], plot_y_data[::skip, ::skip], ax=ax)
m.drawcoastlines(ax=ax)
m.drawparallels(np.arange(-90.,90.,45.), labels=[1, 0, 0, 0], fontsize=10, ax=ax)
m.drawmeridians(np.arange(-180.,180.,60.), labels=[0, 0, 0, 1], fontsize=10, ax=ax)
m.colorbar(location='bottom', pad='7%', ax=ax)
plt.show()
for i in range(40,41):
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(16, 10))
plt.subplots_adjust(left=0.1, right=0.9, bottom=0.1, wspace=0.1)
ax1 = plt.subplot2grid((1,2), (0,0))
ax2 = plt.subplot2grid((1,2), (0,1))
ax1.set_xlim(4,20); ax1.set_xlabel('Temperature, [C]')
#xlim(30,38); xlabel('Salinity, [psu]')
ax1.set_ylabel('Depth, [m]')#;ax1.set_ylim(0,80)
ax1.set_ylim(80, 0)
#ax1 = plt.gca()
#ax1.set_ylim(ax1.get_ylim()[::-1])
ax1.scatter(temptemp[i], depthdepth[i], color='r', label='in-situ')
ax1.scatter(temp[i], dt[15*i:15*i+15], color='b', label='model')
ax1.legend(loc=3)
m2 = Basemap(projection='merc', llcrnrlat=51,urcrnrlat=51.9,llcrnrlon=2.0,urcrnrlon=3.5,lat_ts=51.45, resolution='i', ax=ax2)
m2.drawparallels(arange(51.0,51.9,0.3),labels=[1,0,0,1],fontsize=10)
m2.drawmeridians(arange(2,3.5,0.5),labels=[1,0,0,1],fontsize=10)
m2.drawcoastlines()
m2.drawmapboundary(fill_color='#9999FF')
x4, y4 = m2(x_bcz, y_bcz); lnln, ltlt = m2(lonlon[i], latlat[i]); lg,lt=m2(long[i],lati[i]);clevs = np.arange(0.,60.0,1);cax = fig.add_axes([0.2, 0.08, 0.6, 0.04])
x2, y2 = m2(lon, lat)
cs43 = m2.plot(x4,y4,color='black',linewidth=1.0)
CS4 = m2.contourf(x2,y2,h,clevs,cmap='Blues',animated=True)
cb1 = colorbar(CS4, cax, orientation='horizontal')
m2.drawcountries()
m2.fillcontinents(color='#ddaa66',lake_color='#9999FF')
m2.scatter(lnln,ltlt,20,marker='o',color='r')
m2.scatter(lg,lt,20,marker='o',color='b')
show()
'''
def traj_plot_all_clear_cloudy(*months,
path,
state,
levels=[
'780', '1000', '1400', '1850', '2850',
'3950', '5220', '6730', '8600'
]):
"""
Function to plot trajectories of all clear or cloudy states or according to month
path: path to data file to be plotted
state: clear or cloudy
"""
# specifying the levels or ask user to give levels as a list
#levels = ['780', '1000', '1400', '1850', '2850', '3950', '5220', '6730', '8600']
fig = plt.figure(figsize=(12, 10))
# plt.figure(figsize=(10,8))
m = Basemap(projection='ortho', lat_0=80, lon_0=270, resolution='l')
m.fillcontinents(color='0.75')
m.drawparallels(np.arange(-80., 81., 20.), color='grey')
m.drawmeridians(np.arange(-180., 181., 20.))
mons = [mo for mo in months]
dates_ = []
# checking for clear or cloudy
if (state == 'cloudy'):
for mo in mons:
# makes a list of list
# each month dates are stored as a separate list with dates as strings
dates_.append(
open(
'/home/ollie/muali/python_notebooks/Avg_dates/3havg_cloudy_'
+ mo, 'r').read().split('\n'))
else:
for mo in mons:
dates_ = open(
'/home/ollie/muali/python_notebooks/Avg_dates/3havg_clear_' +
mo, 'r').read().split('\n')
for lvl in levels:
#to loop over all levels
# inner loop for plotting all the trajectories on one map
# read the trajectories to be plotted
for line_ in dates_:
# element by element reading the dates
df = pd.read_csv(path + 'tdump_' + lvl + '_' + line_,
skiprows=7,
header=None,
delim_whitespace=True)
lat = np.array(df.iloc[:, 9].copy())
lon = np.array(df.iloc[:, 10].copy())
#Convert lat lon to map coordinates
x, y = m(lon, lat)
#Plot the points on the map
plt.plot(x, y, linewidth=1.0, color='red')
#source point
xpt, ypt = m(lon[-1], lat[-1])
plt.plot(xpt, ypt, marker='*', markerfacecolor='red', markersize=8)
max_val = np.max(v) levels=[-0.01251*max_val,0.,0.01251*max_val,0.0251*max_val,0.0625*max_val,.1*max_val,.2*max_val,.3*max_val,.4*max_val,.5*max_val,.6*max_val,.7*max_val,.75*max_val,.8*max_val,.9*max_val,1.*max_val] for i in xrange(1): fig = plt.figure(figsize=(48, 48)) m.drawmapboundary(fill_color='white', zorder=-1, linewidth=4.5) m.fillcontinents(color='0.8', lake_color='white', zorder=0) m.drawcoastlines(color='0.0', linewidth=4.5) #m.drawcountries(color='0.', linewidth=4.5) m.drawparallels(np.arange(-90.,91.,30.), labels=[1,0,0,1], dashes=[1,1], linewidth=1.0, color='0.5',fontsize='x-large', fontname='Times') m.drawmeridians(np.arange(0., 360., 60.), labels=[1,0,0,1], dashes=[1,1], linewidth=1.0, color='0.5',fontsize='x-large', fontname='Times') #PLOT ABSOLUTE #cs = m.contourf(X2,Y2,mdata,levels,cmap=cmap,extend='both') cs = m.contourf(X2,Y2,mdata,levels,cmap=cmap) vmin,vmax = (-0.01251*max_val,max_val) plt.tight_layout() #cbar = m.colorbar(cs,location='bottom',pad='10%',ticks=np.linspace(vmin,vmax,7),format='%.1f') ticks = [0.,0.0251*max_val,.1*max_val,.3*max_val,.5*max_val,.7*max_val,.8*max_val,1.*max_val] cbar = m.colorbar(cs,location='bottom',pad='10%',ticks=ticks,format='%.1f') #cbar.ax.get_yaxis().labelpad = 60 cbar.ax.get_xaxis().labelpad = 45
color='k',
fontweight='bold',
fontsize=12,
zorder=10) #xytext=(-500,500),textcoords='offset points'
else: # case of multiple drifters
df = pd.read_csv('http://nefsc.noaa.gov/drifter/drift_' + cluster +
'.csv')
ids = np.unique(df['ID'])
for k in ids:
df1 = df[df['ID'] == k]
df1 = df1[df1['DAY'] == datetime_wanted.day]
x, y = m(df1['LON'].values, df1['LAT'].values)
m.plot(x, y, 'k')
m.drawparallels(np.arange(min(latsize),
max(latsize) + 1, tick_int),
labels=[1, 0, 0, 0])
m.drawmeridians(np.arange(min(lonsize),
max(lonsize) + 1, tick_int),
labels=[0, 0, 0, 1])
#m.drawcoastlines()
m.drawmapboundary()
plt.title(
str(datetime_wanted.strftime("%d-%b-%Y")) + ' ' + agg + '-day ' +
sat_option + ' composite') #+cluster)
plt.savefig(png_dir + sat_option + '_' + area + '_' +
datetime_wanted.strftime('%Y-%m-%d') + '_' + agg + '.png')
plt.show()
gif_name = png_dir + gif_name
make_gif(gif_name,
png_dir,
delat = lats[1] - lats[0]
lons = (lons - 0.5 * delon).tolist()
lons.append(lons[-1] + delon)
lons = np.array(lons, np.float64)
lats = (lats - 0.5 * delat).tolist()
lats.append(lats[-1] + delat)
lats = np.array(lats, np.float64)
# creat figure, axes instances.
fig = plt.figure()
ax = fig.add_axes([0.05, 0.05, 0.9, 0.9])
# create Basemap instance for Robinson projection.
# coastlines not used, so resolution set to None to skip
# continent processing (this speeds things up a bit)
m = Basemap(projection='robin', lon_0=lons.mean(), resolution=None)
# compute map projection coordinates of grid.
x, y = m(*np.meshgrid(lons, lats))
# draw line around map projection limb.
# color background of map projection region.
# missing values over land will show up this color.
m.drawmapboundary(fill_color='0.3')
# plot sst, then ice with pcolor
im1 = m.pcolor(x, y, sst, shading='flat', cmap=plt.cm.jet)
im2 = m.pcolor(x, y, ice, shading='flat', cmap=plt.cm.gist_gray)
# draw parallels and meridians, but don't bother labelling them.
m.drawparallels(np.arange(-90., 120., 30.))
m.drawmeridians(np.arange(0., 420., 60.))
# add colorbar
cb = m.colorbar(im1, "bottom", size="5%", pad="2%")
# add a title.
ax.set_title('SST and ICE analysis for %s' % date)
plt.savefig('plotsst.png')
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)
print resCap.shape
#print resCap[:,0]
#print resCap[:,1]
#print resCap[np.all(grid[:]==[10000.,40000.],axis=1)][0,234]
capMax = np.max(resCap)
startpointx, startpointy = (357309.0, 131195.0)
#startpointx, startpointy = (360000.0, 130000.0)
#fig, ax = plt.subplots()
#grid_x, grid_y = np.mgrid[0:maxx-minx:10000, 0:maxy-miny:10000]
m.fillcontinents(color='lightgray', lake_color='blue', zorder=15)
m.drawcoastlines(zorder=15)
m.drawparallels(np.arange(-80., 81., 20.), zorder=10)
#m.drawmeridians(np.arange(-180.,181.,20.),zorder=0);
m.drawmapboundary(fill_color='white', zorder=10)
#m.plot(startpointx,startpointy,marker='*',markersize=15,zorder=20,color='yellow')
m.plot(357309.0,
131195.0,
marker='*',
markersize=40,
zorder=20,
color='yellow')
m.plot(255000.0,
554000.0,
marker='*',
markersize=40,
zorder=20,
color='yellow')
model_tag = model_names[irow]
m = Basemap(ax=ax,
projection='tmerc',
resolution='l',
llcrnrlat=map_lat_min,
llcrnrlon=map_lon_min,
urcrnrlat=map_lat_max,
urcrnrlon=map_lon_max,
lat_0=map_lat_center,
lon_0=map_lon_center)
m.drawcoastlines(linewidth=0.2)
m.drawcountries(linewidth=0.2)
m.drawparallels(map_parallels,
linewidth=0.1,
labels=[1, 0, 0, 0],
fontsize=8)
m.drawmeridians(map_meridians,
linewidth=0.1,
labels=[0, 0, 0, 1],
fontsize=8)
# contourf model
xx, yy = m(lons2, lats2)
zz = np.transpose(model[model_tag])
if model_tag in ['dlnvs']:
#z_max = round_to_1(np.max(np.abs(zz)))
#dz = 2.0*z_max/10
#levels = np.arange(-z_max, z_max+dz/2, dz)
zz = zz * 100 # use percentage
resolution='l',
round=True)
elif style == 'polar':
m = Basemap(projection='npstere',
boundinglat=66,
lon_0=270,
resolution='l',
round=True)
m.drawmapboundary(fill_color='white')
m.drawcoastlines(color='k', linewidth=0.3)
parallels = np.arange(50, 90, 10)
meridians = np.arange(-180, 180, 30)
m.drawparallels(parallels,
labels=[False, False, False, False],
linewidth=0.5,
color='k',
fontsize=4)
mer = m.drawmeridians(meridians,
labels=[True, True, False, False],
linewidth=0.5,
color='k',
fontsize=4)
m.drawlsmask(land_color='darkgrey', ocean_color='w')
setcolor(mer, 'white')
### Adjust maximum limits
values = np.arange(-2, 2.1, .2)
### Plot filled contours
cs = m.contourf(lons[:, :],
from mpl_toolkits.basemap import Basemap
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.animation as animation
import urllib.request
import json
# basic map setup
globe = Basemap(projection='robin', resolution='c', lat_0=0, lon_0=0)
globe.drawcoastlines()
globe.drawcountries()
globe.fillcontinents(color="grey")
globe.drawmapboundary()
globe.drawmeridians(np.arange(0, 360, 30))
globe.drawparallels(np.arange(-90, 90, 30))
x, y = globe(0, 0)
point = globe.plot(x, y, 'ro', markersize=7)[0]
def init():
point.set_data([], [])
return point,
# animation function. This is called sequentially
def animate(i):
lons, lats = iss_position()
x, y = globe(lons, lats)
point.set_data(x, y)
return point,
V2d[zoom[1]:zoom[3], zoom[0]:zoom[2]],
cmap=cmap,
norm=nrm_value)
# ft = carte.pcolormesh(x0[1:nj-3,3:ni],y0[1:nj-3,3:ni],V2d[1:nj-3,3:ni], cmap = cmap, norm=nrm_value )
#ft = carte.pcolormesh(x0,y0,V2d, norm=nrm_value )
#carte.etopo()
#carte.shadedrelief()
carte.drawcoastlines(linewidth=0.5)
# xstep=45
# ystep=20
carte.drawmeridians(nmp.arange(vp[0], vp[2] + xstep, xstep),
labels=[1, 1, 1, 1],
linewidth=0.3)
carte.drawparallels(nmp.arange(vp[1], vp[3] + ystep, ystep),
labels=[1, 1, 1, 1],
linewidth=0.3)
# add color bar :
ax3 = plt.axes([0.1, 0.05, 0.80, 0.015])
clb = mpl.colorbar.ColorbarBase(ax3,
ticks=vc_value,
cmap=cmap,
norm=nrm_value,
orientation='horizontal')
# Add title
# ax.annotate('ENERGETICS', xy=(0.02, 0.9), xycoords='figure fraction')
ax.annotate(cname + '(' + unit + ') ' + datstr,
xy=(0.3, 0.93),
m = Basemap(llcrnrlon=0,
llcrnrlat=-90,
urcrnrlon=360,
urcrnrlat=90,
projection='mill')
lons, lats = np.meshgrid(lon, lat)
x, y = m(lons, lats)
fig1 = plt.figure(figsize=(16, 20))
ax = fig1.add_axes([0.1, 0.1, 0.8, 0.8])
clevs = np.linspace(-240, 240, 21)
CS1 = m.contour(x, y, pre_1997, clevs, linewidths=0.5, colors='k')
CS2 = m.contourf(x, y, pre_1997, clevs, cmap=plt.cm.RdBu_r)
m.drawmapboundary(fill_color='#99ffff')
m.drawcoastlines(linewidth=1.5)
m.drawparallels(np.arange(-90, 90, 20), labels=[1, 1, 0, 0])
m.drawmeridians(np.arange(0., 360., 20.), labels=[0, 0, 0, 1])
cbar = m.colorbar(CS2, location='bottom', pad="5%")
cbar.set_label('mm')
plt.title('Regression Precipitation Anomaly in 1997')
plt.savefig("./1997.png", dpi=500)
fig2 = plt.figure(figsize=(16, 20))
ax = fig2.add_axes([0.1, 0.1, 0.8, 0.8])
clevs = np.linspace(-240, 240, 21)
CS1 = m.contour(x, y, pre_1998, clevs, linewidths=0.5, colors='k')
CS2 = m.contourf(x, y, pre_1998, clevs, cmap=plt.cm.RdBu_r)
m.drawmapboundary(fill_color='#99ffff')
m.drawcoastlines(linewidth=1.5)
m.drawparallels(np.arange(-90, 90, 20), labels=[1, 1, 0, 0])
m.drawmeridians(np.arange(0., 360., 20.), labels=[0, 0, 0, 1])
fig = plt.figure()
# create an Axes at an arbitrary location, which makes a list of [left, bottom, width, height] values in 0-1 relative figure coordinates:
ax = fig.add_axes([0.1,0.1,0.8,0.8])
# create Basemap instance.
m = Basemap(projection='cyl', lat_0=0, lon_0=0)
m.drawcoastlines(linewidth=1.25)
m.fillcontinents(color='0.95')
#m.drawmapboundary(fill_color='0.9')
# cacluate colorbar ranges
#bounds_max=float("{0:.0f}".format(np.nanpercentile(Plot_Var, 99.99))) # Upper bound of plotted values to be used for colorbar, which is 99.99th percentile of data, with 0 decimals
bounds_max=33
bounds = np.arange(0, bounds_max, bounds_max/33)
norm = matplotlib.colors.BoundaryNorm(boundaries=bounds, ncolors=256)
# create a pseudo-color plot over the map
im1 = m.pcolormesh(Lon_img, Lat_img, Plot_Var, norm=norm, shading='flat', cmap=plt.cm.jet, latlon=True) # Choose colormap: https://matplotlib.org/users/colormaps.html
m.drawparallels(np.arange(-90.,90.001,30.),labels=[True,False,False,False], linewidth=0.01) # labels = [left,right,top,bottom]
m.drawmeridians(np.arange(0.,360.,30.),labels=[False,False,False,True], linewidth=0.01) # labels = [left,right,top,bottom]
# add colorbar
cbar = m.colorbar(im1,"right", size="3%", pad="2%", extend='max') # extend='both' will extend the colorbar in both sides (upper side and down side)
cbar.set_label(Var_plot_unit)
#set title
ax.set_title(Var_plot_name+', at surface - hist - average of '+start_date_cal_hist+'-'+end_date_cal_hist + ' - ' +str(GCM))
mng = plt.get_current_fig_manager()
mng.window.showMaximized() # Maximizes the plot window to save figures in full
#plt.show()
fig.savefig(dir_figs+Var_name+'_'+ str(GCM)+'_surface_hist-' +start_date_cal_hist+'-'+end_date_cal_hist + '.png', format='png', dpi=300, transparent=True, bbox_inches='tight')
plt.close()
print('Model '+str(GCM)+' - hist - processed successfully')
#################################################
def draw_map(station_etude,
latm,
latM,
lonm,
lonM,
path,
all_pos,
hw,
vn_ITRF,
ve_ITRF,
plot_vertical_ITRF,
incvn_ITRF,
incve_ITRF,
incplot_vertical_ITRF,
plot_GEBCO=False,
plot_vertical=False,
plot_topo=True,
plot_ellipses=True,
coarse_lines=False,
legend_arrow_length=("1 cm/yr", 0.01),
legend_ellipse_size=("2 mm/yr", 0.002),
legend_position=(0.5, 0.9),
scale_arrow=15000000,
scale_ellipse=10000000,
name_stats=True,
name_stats_font_size=8,
name_stats_offset=(0.005, 0.01),
shorten_oversized_arrows=True,
exclude_points_out_of_range=True,
adjust_text=False,
pixels_hires_backgrnd=2000,
draw_borders=True,
full_return=False,
draw_latlon_lines=True):
"""
"""
nstation = len(station_etude)
fig, ax = plt.subplots(figsize=(7, 8))
if incvn_ITRF is None:
incvn_ITRF = np.zeros(len(station_etude))
if incve_ITRF is None:
incve_ITRF = np.zeros(len(station_etude))
if incplot_vertical_ITRF is None:
incplot_vertical_ITRF = np.zeros(len(station_etude))
if coarse_lines:
resolution = "l"
else:
resolution = "h"
m = Basemap(projection='merc',
llcrnrlat=latm,
urcrnrlat=latM,
llcrnrlon=lonm,
urcrnrlon=lonM,
lat_ts=-20,
resolution=resolution,
area_thresh=1,
epsg=3395)
if draw_borders:
m.drawcoastlines(linewidth=0.25)
m.drawcountries()
m.drawstates()
if plot_topo:
m.arcgisimage(service='World_Shaded_Relief',
xpixels=pixels_hires_backgrnd,
verbose=True)
else:
m.drawmapboundary(fill_color='#97B6E1')
m.fillcontinents(color='#EFEFDB', lake_color='#97B6E1', zorder=1)
m.shadedrelief()
if not plot_GEBCO:
color1 = 'black'
else:
color1 = 'white'
levels = [-8000, -7000, -6000, -5500, -5000, -4500,
-4000] #Niveaux pour l'echelle de couleur
gebconc = Dataset(path + 'GEBCO\\GRIDONE_2D.nc')
#Vecteur longitudes/latitudes
long_ini = gebconc.variables['lon'][:]
lats_ini = gebconc.variables['lat'][:]
(lats_area, longs_area,
gebco_area) = area(long_ini, lats_ini, gebconc, latm, latM, lonm,
lonM, '0-180') #lat bas,lat haut, long
(longs, lats, gebco) = split_grid(longs_area, lats_area, gebco_area, 2)
(longs_gr, lats_gr) = np.meshgrid(longs, lats)
fond = m.pcolormesh(longs_gr,
lats_gr,
gebco,
shading='flat',
cmap=LevelColormap(list(np.asarray(levels) * (1)),
cmap=cm.deep_r),
latlon=True) #ice,deep
cbar = m.colorbar(location='top', pad=0.5)
cbar.set_label('Depth [m] ', rotation=0)
if draw_latlon_lines:
m.drawparallels(np.arange(latm, latM, 1.),
fontsize=10,
color=color1,
labels=[True, False, False, False],
linewidth=0.25,
dashes=[10000, 1]) #de -180 a 360 par pas de 5° ;
m.drawmeridians(np.arange(lonm, lonM, 1.),
fontsize=10,
color=color1,
labels=[False, False, False, True],
linewidth=0.25,
dashes=[10000, 1]) # Haut / G/D/BAS
### Labels
plt.xlabel('Longitude (°) ', labelpad=25, fontsize=10)
plt.ylabel('Latitude (°) ', labelpad=40, fontsize=10)
ax.yaxis.set_label_position("left")
all_posx_proj = [0] * nstation
all_posy_proj = [0] * nstation
for i in range(nstation):
all_posx_proj[i], all_posy_proj[i] = m(
all_pos[i][1], all_pos[i][0]
) #positions xy des stations converties a la projection de la carte [m]
print(i, all_posx_proj[i], all_posy_proj[i])
m.plot(
all_posx_proj[i],
all_posy_proj[i],
'xkcd:black',
marker='.',
linestyle='none',
markersize=4,
lw=4,
zorder=20
) #point rouge à la station, zorder indique l'ordre vertical de dessin sur la carte, les nb elevés sont dessinés les plus hauts
# plt.text(all_posx_proj[i], all_posy_proj[i], station_etude[i], size=10,ha="center", va="center",bbox=dict(boxstyle="round",
# ec=(1., 0.5, 0.5),
# fc=(1., 0.8, 0.8),
# )
# )
############### DICO POUR FLECHES DEFINITION
arrow_prop_dict = dict(arrowstyle='->,head_length=0.8,head_width=0.3',
ec='xkcd:black',
fc='xkcd:black',
linewidth=2)
arrow_prop_dict_V_up = dict(arrowstyle='->,head_length=0.8,head_width=0.3',
ec='xkcd:green',
fc='xkcd:green',
linewidth=2)
arrow_prop_dict_V_down = dict(
arrowstyle='->,head_length=0.8,head_width=0.3',
ec='xkcd:red orange',
fc='xkcd:red orange',
linewidth=2)
arrow_prop_dict_V_up_short = dict(
arrowstyle='->,head_length=0.8,head_width=0.3',
ec='xkcd:green',
fc='xkcd:green',
linewidth=2,
linestyle="--")
arrow_prop_dict_V_down_short = dict(
arrowstyle='->,head_length=0.8,head_width=0.3',
ec='xkcd:red orange',
fc='xkcd:red orange',
linewidth=2,
linestyle="--")
if not plot_vertical: #CHAMP VITESSES HORIZONTALES
for i in range(nstation):
######### Exclude point if not in range
#latm,latM,lonm,lonM
bool_good_lat = latm < all_pos[i][0] < latM
bool_good_lon = lonm < all_pos[i][1] < lonM
if exclude_points_out_of_range and not (bool_good_lat
and bool_good_lon):
print("INFO : exclude point because out of range")
continue
x_end_arrow_ok = all_posx_proj[i] + np.multiply(
ve_ITRF[i], scale_arrow)
y_end_arrow_ok = all_posy_proj[i] + np.multiply(
vn_ITRF[i], scale_arrow)
ax.annotate(
s='',
xy=(x_end_arrow_ok, y_end_arrow_ok),
xytext=(all_posx_proj[i], all_posy_proj[i]),
arrowprops=arrow_prop_dict,
annotation_clip=True
) #xy point arrivee de la fleche, xytext l'origine de la fleche
a = math.atan(
(all_posx_proj[i] + np.multiply(ve_ITRF[i], scale_arrow) -
all_posy_proj[i]) /
(all_posy_proj[i] + np.multiply(ve_ITRF[i], scale_arrow) -
all_posy_proj[i])
) # l'angle d'orientation de l'ellipsoide, avec 0 au nord et +90 a l'ouest
e = Ellipse(
xy=(x_end_arrow_ok, y_end_arrow_ok),
width=np.multiply(2, incve_ITRF[i]) * scale_ellipse,
height=np.multiply(2, incvn_ITRF[i]) * scale_ellipse,
angle=a
) #multiplication par 2 pour obtenir la largeur et la hauteur de l'ellipse
# STATION NAME
if name_stats:
offset_x_ok, offset_y_ok = utils.axis_data_coords_sys_transform(
ax, name_stats_offset[0], name_stats_offset[1])
plt.text(all_posx_proj[i] + offset_x_ok,
all_posy_proj[i] + offset_y_ok,
station_etude[i],
fontsize=name_stats_font_size)
# ELIPSES
if plot_ellipses:
ax.add_artist(e)
e.set_clip_box(ax.bbox)
e.set_edgecolor('none')
e.set_facecolor('black')
e.set_alpha(0.3)
e.set_zorder(1)
else: # Champ de vitesses verticales ITRF
############### PLOT FLECHES
Text = []
for i in range(nstation):
######### Exclude point if not in range
#latm,latM,lonm,lonM
bool_good_lat = latm < all_pos[i][0] < latM
bool_good_lon = lonm < all_pos[i][1] < lonM
if exclude_points_out_of_range and not (bool_good_lat
and bool_good_lon):
print("INFO : exclude point because out of range")
continue
######### AJUSTEMENT SI FLECHES TROP GRANDES
x_end_arrow, y_end_arrow = all_posx_proj[i], all_posy_proj[
i] + np.multiply(plot_vertical_ITRF[i], scale_arrow)
x_end_axis_ref, y_end_axis_ref = utils.axis_data_coords_sys_transform(
ax, x_end_arrow, y_end_arrow, inverse=True)
if (y_end_axis_ref < 0.) and shorten_oversized_arrows:
shortened_arrow = True
x_end_arrow_ok = x_end_arrow
_, y_end_arrow_ok = utils.axis_data_coords_sys_transform(
ax, x_end_axis_ref, 0, inverse=False)
elif (y_end_axis_ref > 1.) and shorten_oversized_arrows:
shortened_arrow = True
x_end_arrow_ok = x_end_arrow
_, y_end_arrow_ok = utils.axis_data_coords_sys_transform(
ax, x_end_axis_ref, 1., inverse=False)
else:
shortened_arrow = False
x_end_arrow_ok = x_end_arrow
y_end_arrow_ok = y_end_arrow
######### FIN AJUSTEMENT SI FLECHES TROP GRANDES
### SELECT ARROW PROPERTY DEPENDING ON THE TYPE
if plot_vertical_ITRF[i] > 0 and not shortened_arrow:
arrow_prop_dict_V = arrow_prop_dict_V_up
elif plot_vertical_ITRF[i] > 0 and shortened_arrow:
arrow_prop_dict_V = arrow_prop_dict_V_up_short
elif plot_vertical_ITRF[i] <= 0 and not shortened_arrow:
arrow_prop_dict_V = arrow_prop_dict_V_down
elif plot_vertical_ITRF[i] <= 0 and shortened_arrow:
arrow_prop_dict_V = arrow_prop_dict_V_down_short
### PLOT
ax.annotate(s='',
xy=(x_end_arrow_ok, y_end_arrow_ok),
xytext=(all_posx_proj[i], all_posy_proj[i]),
arrowprops=arrow_prop_dict_V,
annotation_clip=False)
#xy point arrivee de la fleche, xytext l'origine de la fleche
### STATION NAME
if name_stats:
offset_x_ok, offset_y_ok = utils.axis_data_coords_sys_transform(
ax, name_stats_offset[0], name_stats_offset[1])
Text.append(
plt.text(all_posx_proj[i] + offset_x_ok,
all_posy_proj[i] + offset_y_ok,
station_etude[i],
fontsize=name_stats_font_size))
############### PLOT ELLIPSES
# angle de l'ellipse dépend de la direction du vecteur vitesse
a = math.atan(
(all_posx_proj[i] + np.multiply(
plot_vertical_ITRF[i], scale_arrow) - all_posx_proj[i]) /
(all_posy_proj[i] + np.multiply(
plot_vertical_ITRF[i], scale_arrow) - all_posy_proj[i])
) # l'angle d'orientation de l'ellipsoide, avec 0 au nord et +90 a l'ouest
# weird previous xy definition
# [all_posx_proj[i]+np.multiply(plot_vertical_ITRF[i],0),all_posy_proj[i]+0.85*np.multiply(plot_vertical_ITRF[i],scale_arrow)]
e = Ellipse(
xy=(x_end_arrow_ok, y_end_arrow_ok),
width=np.multiply(2, incplot_vertical_ITRF[i]) * scale_ellipse,
height=np.multiply(2, incplot_vertical_ITRF[i]) *
scale_ellipse,
angle=a
) #multiplication par 2 pour obtenir la largeur et la hauteur de l'ellipse
# ax.plot(all_posx_proj[i]+np.multiply(plot_vertical_ITRF[i],0),all_posy_proj[i]+np.multiply(plot_vertical_ITRF[i],scale_arrow),'xkcd:green',marker='.',linestyle='none',markersize=4,lw=4,zorder=20) #point rouge à la station, zorder indique l'ordre vertical de dessin sur la carte, les nb elevés sont dessinés les plus hauts
ax.add_artist(e)
e.set_clip_box(ax.bbox)
e.set_edgecolor('none')
e.set_facecolor('black')
e.set_alpha(0.3)
e.set_zorder(1)
############### LEGENDE
legend_arrow_length_label = legend_arrow_length[0]
legend_ellipse_size_label = legend_ellipse_size[0]
legend_arrow_length_metric = legend_arrow_length[1]
legend_ellipse_size_metric = legend_ellipse_size[1]
legend_position_x = legend_position[0]
legend_position_y = legend_position[1]
######## Fleche de Legende
### origine de la fleche de legende
xl, yl = utils.axis_data_coords_sys_transform(ax,
legend_position_x,
legend_position_y + 0.02,
inverse=False)
### fin de la fleche de legende
xe, ye = xl + np.multiply(legend_arrow_length_metric, scale_arrow), yl
plt.annotate(
s='', xy=(xe, ye), xytext=(xl, yl), arrowprops=arrow_prop_dict
) #xy point arrivee de la fleche, xytext l'origine de la fleche
props = dict(boxstyle='round', facecolor='black', alpha=0)
ax.text(legend_position_x,
legend_position_y + 0.035,
'Velocity : ' + legend_arrow_length_label,
transform=ax.transAxes,
fontsize=11,
color='black',
verticalalignment='bottom',
bbox=props) # place a text box in upper left in axes coords
######## Légende de l'ellipse d'incertitude
ax.text(legend_position_x,
legend_position_y,
'+/- ' + legend_ellipse_size_label + ' (radius)',
transform=ax.transAxes,
fontsize=11,
color='black',
verticalalignment='top',
bbox=props)
ells_legend = Ellipse(xy=[xe, ye],
width=np.multiply(
2,
np.multiply(legend_ellipse_size_metric,
scale_ellipse)),
height=np.multiply(
2,
np.multiply(legend_ellipse_size_metric,
scale_ellipse)),
angle=a)
if plot_ellipses:
ax.add_artist(ells_legend)
ells_legend.set_clip_box(ax.bbox)
ells_legend.set_edgecolor('none')
ells_legend.set_facecolor('black')
ells_legend.set_alpha(0.3)
ells_legend.set_zorder(1)
############### FINITION
for T in Text: #Put label in front
T.set_zorder(100)
if adjust_text:
from adjustText import adjust_text
adjust_text(
Text,
on_basemap=True) #arrowprops=dict(arrowstyle='->', color='red')
plt.tight_layout()
if full_return:
return fig, ax, m, Text
else:
return fig, ax, m, Text
lon = DS['lon'][:]
lat = DS['lat'][:]
time = DS['time'][:]
area = DS['area'][:] / (1e5)
## Plot
# set up orthographic map projection with
# perspective of satellite looking down at 50N, 100W.
# use low resolution coastlines.
#map = Basemap(projection='hammer',lon_0=180)
map = Basemap(llcrnrlon=0.,llcrnrlat=-50.,urcrnrlon=360.,urcrnrlat=50.,\
resolution='l',projection='merc')
# draw coastlines, country boundaries, fill continents.
map.fillcontinents(color='lightgray',zorder=1)
map.drawcoastlines(color='k',linewidth=0.7,zorder=10)
map.drawcountries(color='k',linewidth=0.5,zorder=10)
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary()
# draw lat/lon grid lines every 30 degrees.
map.drawmeridians(np.arange(0,360,30),zorder=15)
map.drawparallels(np.arange(-90,90,30),zorder=15)
x, y = map(lon, lat)
map.scatter(x,y, area, marker='o',facecolors='none', edgecolors='blue',zorder=5)
plt.title(out_str)
print(fout)
plt.savefig(fout, dpi = 150,bbox_inches='tight')
def fr2ghi2png(url,
colormapPath,
colormapName,
dirDest,
lat_name,
lon_name,
data_name,
geos=False):
# Dataset is the class behavior to open the file
# and create an instance of the ncCDF4 class
nc_fid = netCDF4.Dataset(url, 'r')
t_coverage = repr(nc_fid.getncattr('time_coverage_start'))
# print t_coverage
ds_name = repr(nc_fid.getncattr('dataset_name'))
# print ds_name
date = re.search('\'(.*?)\'', t_coverage).group(1)
print(date)
channel = re.search('-M\d(.*?)_', ds_name).group(1)
print(channel)
yl = date[0:4]
yy = date[2:4]
mt = date[5:7]
dd = date[8:10]
hh = date[11:13]
mm = date[14:16]
ss = date[17:19]
str_date = str(dd) + '/' + str(mt) + '/' + str(yl) + " " + str(
hh) + ":" + str(mm)
date = datetime.datetime.strptime(
str_date, '%d/%m/%Y %H:%M') - datetime.timedelta(hours=3)
name = channel + " " + date.strftime('%d-%m-%Y %H:%M')
filename = channel + "_" + yy + mt + dd + "_" + hh + mm + ss
# print "name: " + name
# extract/copy the data
data = nc_fid.variables[data_name][:]
if data_name == 'CMI' or data_name == 'Rad':
# Satellite height
sat_h = nc_fid.variables[
'goes_imager_projection'].perspective_point_height
# Satellite longitude
sat_lon = nc_fid.variables[
'goes_imager_projection'].longitude_of_projection_origin
# Satellite sweep
sat_sweep = nc_fid.variables['goes_imager_projection'].sweep_angle_axis
X = nc_fid.variables[lon_name][:] # longitud, eje X
Y = nc_fid.variables[lat_name][:] # latitud, eje Y
scene_id_val = repr(nc_fid.getncattr('scene_id'))
scene_id = re.search('\'(.*?)\'', scene_id_val).group(1)
nc_fid.close()
print("Realizando pasaje a K en C13 y truncamiento en los otros")
for d in numpy.nditer(data, op_flags=['readwrite']):
d = truncUno(d)
data *= 100
#######################################
#######################################
name = "GHI " + date.strftime('%d-%m-%Y %H:%M')
nc_fid_ghi = netCDF4.Dataset(url, 'r')
data = nc_fid_ghi.variables[data_name][:]
X = nc_fid_ghi.variables[lon_name][:] # longitud, eje X
Y = nc_fid_ghi.variables[lat_name][:] # latitud, eje Y
nc_fid_ghi.close()
for d in numpy.nditer(data, op_flags=['readwrite']):
d = truncUno(d)
data *= 100
X *= sat_h
Y *= sat_h
vmin = 0.0
vmax = 1200.0
ax = Basemap(projection='merc',\
llcrnrlat=-35.00,urcrnrlat=-30.00,\
llcrnrlon=-58.77,urcrnrlon=-53.00,\
resolution='f')
projection = Proj(proj='geos',
h=sat_h,
lon_0=sat_lon,
sweep=sat_sweep,
ellps='WGS84')
x_mesh, y_mesh = numpy.meshgrid(X, Y)
lons, lats = projection(x_mesh, y_mesh, inverse=True)
x, y = ax(lons, lats)
ax.drawcoastlines(linewidth=0.40)
ax.drawcountries(linewidth=0.40)
ax.drawstates(linewidth=0.20)
rincon_de_artigas_poly(ax)
par = ax.drawparallels(numpy.arange(-40, -20, 2),
labels=[1, 0, 0, 0],
linewidth=0.0,
fontsize=7,
color='white')
mer = ax.drawmeridians(numpy.arange(-70, -40, 2),
labels=[0, 0, 1, 0],
linewidth=0.0,
fontsize=7,
color='white')
setcolor(par, 'white')
setcolor(mer, 'white')
print("Calculando GHI...")
Isc = 1367.0
# JPTv1
a = 0.602
b = 0.576
c = -0.341
d = -13.149
def FR2GHI(lat, lon, fr):
Cz, Gamma = cosSolarZenithAngle(lat, lon, date, 0)
ghi = 0.
if Cz > 0.:
Fn = FnFunc(Gamma)
ghi = Isc * Fn * Cz * (a + b * Cz + c * Cz) + d * fr
if Isc * Fn * Cz != 0:
Kt = ghi / (Isc * Fn * Cz)
Kt = numpy.clip(Kt, 0.09, 0.85)
ghi = Kt * Isc * Fn * Cz
return ghi
FR2GHI_vect = numpy.vectorize(FR2GHI, otypes=[float])
GHI = FR2GHI_vect(lats, lons, data)
ticks = [0, 200, 400, 600, 800, 1000, 1200]
ticksLabels = ticks
cmap = gmtColormap('irradiancia_v6', colormapPath, 2048)
cs = ax.pcolormesh(x, y, GHI, vmin=vmin, vmax=vmax, cmap=cmap)
plt.clim(vmin, vmax)
# agrego el colorbar
cbar = ax.colorbar(cs, location='bottom', ticks=ticks) # , pad='3%'
cbar.ax.set_xlabel(
"Irradiancia solar global en plano horizontal ($W/m^2$)",
fontsize=7,
color='white')
cbar.ax.set_xticklabels(ticksLabels, fontsize=7, color='white')
# agrego el logo en el documento
logo_bw = plt.imread('/sat/PRS/dev/PRS-sat/PRSgoes/logo_300_bw.png')
plt.figimage(logo_bw, xo=5, yo=5)
if not os.path.isdir(dirDest + channel + '/' + yl + '/ghi'):
os.mkdir(dirDest + channel + "/" + yl + '/ghi')
# if
outPath = dirDest + channel + "/" + yl + "/ghi/"
whitePath = outPath + filename + '_ghi_white.png' # determino el nombre del archivo a escribir
outPath = outPath + filename + '_ghi.png' # determino el nombre del archivo a escribir
x_coord = 109
y_coord = -53
Noche = numpy.sum(data) <= 0.
if Noche: # print "es noche"
plt.annotate("NOCHE", (0, 0), (204, 15),
color='white',
xycoords='axes fraction',
textcoords='offset points',
va='top',
fontsize=10,
family='monospace')
plt.annotate(name + " UY", (0, 0), (x_coord, y_coord),
xycoords='axes fraction',
textcoords='offset points',
va='top',
fontsize=11,
family='monospace',
color='white')
plt.savefig(outPath, bbox_inches='tight', dpi=400,
transparent=True) # , facecolor='#4F7293'
cbar.ax.set_xlabel(
"Irradiancia solar global en plano horizontal ($W/m^2$)",
fontsize=7,
color='black')
cbar.ax.set_xticklabels(ticksLabels, fontsize=7, color='black')
# WHITE
setcolor(par, 'black')
setcolor(mer, 'black')
logo_color = plt.imread('/sat/PRS/dev/PRS-sat/PRSgoes/logo_300_color.png')
plt.figimage(logo_color, xo=5, yo=5)
nota_ghi_w = plt.annotate(name + " UY", (0, 0), (x_coord, y_coord),
xycoords='axes fraction',
textcoords='offset points',
va='top',
fontsize=11,
family='monospace',
color='black')
plt.savefig(whitePath,
bbox_inches='tight',
dpi=400,
transparent=False,
facecolor='white') # , facecolor='#4F7293'
copyfile(outPath, dirDest + channel + '_ghi.png')
copyfile(whitePath, dirDest + channel + '_ghi_white.png')
print("NUBOSIDAD")
# NUBOSIDAD
plt.clf()
ax.drawcoastlines(linewidth=0.40)
ax.drawcountries(linewidth=0.40)
ax.drawstates(linewidth=0.20)
rincon_de_artigas_poly(ax)
par = ax.drawparallels(numpy.arange(-40, -20, 2),
labels=[1, 0, 0, 0],
linewidth=0.0,
fontsize=7,
color='white')
mer = ax.drawmeridians(numpy.arange(-70, -40, 2),
labels=[0, 0, 1, 0],
linewidth=0.0,
fontsize=7,
color='white')
setcolor(par, 'white')
setcolor(mer, 'white')
vmin = 0.0
vmax = 100.0
ticks = [0, 20, 40, 60, 80, 100]
ticksLabels = ticks
cmap = gmtColormap('nubosidad', colormapPath, 2048)
cs = ax.pcolormesh(x, y, data, vmin=vmin, vmax=vmax, cmap=cmap)
plt.clim(vmin, vmax)
# agrego el colorbar
cbar = ax.colorbar(cs, location='bottom', ticks=ticks) # , pad='3%'
cbar.ax.set_xlabel("Nubosidad (%)", fontsize=7, color='white')
cbar.ax.set_xticklabels(ticksLabels, fontsize=7, color='white')
plt.figimage(logo_bw, xo=5, yo=5)
outPath = dirDest + channel + "/" + yl + "/ghi/"
outPath = outPath + filename + '_cloud.png' # determino el nombre del archivo a escribir
whitePath = outPath + filename + '_cloud_white.png' # determino el nombre del archivo a escribir
x_coord = 109
y_coord = -53
plt.annotate("C02 " + date.strftime('%d-%m-%Y %H:%M') + " UY", (0, 0),
(x_coord, y_coord),
xycoords='axes fraction',
textcoords='offset points',
va='top',
fontsize=11,
family='monospace',
color='white')
plt.draw()
plt.savefig(outPath, bbox_inches='tight', dpi=400,
transparent=True) # , facecolor='#4F7293'
# CLOUD WHITE
setcolor(par, 'black')
setcolor(mer, 'black')
logo_color = plt.imread('/sat/PRS/dev/PRS-sat/PRSgoes/logo_300_color.png')
plt.figimage(logo_color, xo=5, yo=5)
plt.annotate("C02 " + date.strftime('%d-%m-%Y %H:%M') + " UY", (0, 0),
(x_coord, y_coord),
xycoords='axes fraction',
textcoords='offset points',
va='top',
fontsize=11,
family='monospace',
color='black')
plt.savefig(whitePath,
bbox_inches='tight',
dpi=400,
transparent=False,
facecolor='white') # , facecolor='#4F7293'
copyfile(outPath, dirDest + channel + '_cloud.png')
copyfile(whitePath, dirDest + channel + '_cloud_white.png')
plt.close()
def cs_figure(profile,
structures,
min_length=None,
max_length=None,
ymin=None,
ylim=None,
extrap_range=300,
contacts=None,
locations=None,
id_measurements=False,
save=False,
save_name='cross_section.pdf'):
if min_length is None:
min_length = int(min(profile.length.tolist()))
if max_length is None:
max_length = int(max(profile.length.tolist()))
if ymin is None:
ymin = int(min(profile.elevation.tolist()) * 0.5)
if ylim is None:
ylim = int(max(profile.elevation.tolist()) * 1.3)
min_ind = profile.loc[profile['length'] == find_nearest(
np.array(profile.length.tolist()), min_length)].index.tolist()[0]
med_ind = profile.loc[profile['length'] == find_nearest(
np.array(profile.length.tolist()), (max_length) / 2)].index.tolist()[0]
max_ind = profile.loc[profile['length'] == find_nearest(
np.array(profile.length.tolist()), max_length)].index.tolist()[0]
min_cs_lat = profile['lat'][min_ind]
med_cs_lat = profile['lat'][med_ind]
max_cs_lat = profile['lat'][max_ind]
min_cs_lon = profile['lon'][min_ind]
med_cs_lon = profile['lon'][med_ind]
max_cs_lon = profile['lon'][max_ind]
if locations:
loc_coor = {}
for location in locations:
loc_mid = np.average(
[locations[location][0], locations[location][1]])
loc_ind = profile.loc[profile['length'] == find_nearest(
np.array(profile.length.tolist()), loc_mid)].index.tolist()[0]
loc_lat = profile['lat'][loc_ind]
loc_lon = profile['lon'][loc_ind]
loc_coor[location] = [loc_lat, loc_lon]
plt.figure(figsize=(12, 8))
ax1 = plt.subplot2grid((2, 3), (0, 0), colspan=1)
m = Basemap(projection='merc',
llcrnrlat=46.2,
urcrnrlat=48,
llcrnrlon=-91,
urcrnrlon=-88,
resolution='i') #lat_ts=-25
m.drawrivers(color='#99ffff')
m.drawcoastlines()
m.drawmapboundary(fill_color='#99ffff')
m.fillcontinents(color='#cc9966', lake_color='#99ffff')
parallels = [min_cs_lat] #np.arange(-90,90,2.)
m.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10)
meridians = [min_cs_lon] #np.arange(0.,360.,2.)
m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10)
X, Y = m([min_cs_lon, max_cs_lon, max_cs_lon, min_cs_lon, min_cs_lon],
[max_cs_lat, max_cs_lat, min_cs_lat, min_cs_lat, max_cs_lat])
m.plot(X, Y, color='k', markersize=300, zorder=50)
ax2 = plt.subplot2grid((2, 3), (0, 1), colspan=1)
zoom_rescale = abs(0.5 * (max(profile.length) / 111100))
m = Basemap(projection='merc',
llcrnrlat=med_cs_lat - zoom_rescale,
urcrnrlat=med_cs_lat + zoom_rescale,
llcrnrlon=med_cs_lon - 2 * zoom_rescale,
urcrnrlon=med_cs_lon + 2 * zoom_rescale,
resolution='i') #lat_ts=-25
m.drawrivers(color='#99ffff')
m.drawcoastlines()
m.drawmapboundary(fill_color='#99ffff')
m.fillcontinents(color='#cc9966', lake_color='#99ffff')
parallels = np.arange(-90, 90, 2.)
m.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10)
meridians = np.arange(0., 360., 2.)
m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10)
X, Y = m([profile['lon'][min_ind], profile['lon'][max_ind]],
[profile['lat'][min_ind], profile['lat'][max_ind]])
m.plot(X, Y, linestyle='dotted', linewidth=2, zorder=50)
if locations:
for location in locations:
X, Y = m(loc_coor[location][1], loc_coor[location][0])
m.scatter(X, Y, label=location, color='r', zorder=51)
plt.legend()
ax3 = plt.subplot2grid((2, 3), (0, 2), colspan=1)
ax3.plot(profile.length.tolist(), profile.elevation.tolist())
ax3.text(0,
1,
'{:.5}\n{:.5}'.format(profile.lat.tolist()[0],
profile.lon.tolist()[0]),
transform=ax3.transAxes,
bbox=dict(facecolor='white', edgecolor='white'),
zorder=50)
ax3.text(1,
1,
'{:.5}\n{:.5}'.format(profile.lat.tolist()[len(profile) - 1],
profile.lon.tolist()[len(profile) - 1]),
transform=ax3.transAxes,
bbox=dict(facecolor='white', edgecolor='white'),
zorder=50)
plt.xlim(min(profile.length), max(profile.length))
plt.tight_layout()
ax4 = plt.subplot2grid((2, 3), (1, 0), colspan=3)
plt.plot(profile.length.tolist(), profile.elevation.tolist())
contact_strat = {}
strat = 0
structures = structures.loc[structures['length'] >= min_length].loc[
structures['length'] <= max_length]
structures.reset_index(inplace=True, drop=True)
for n in range(len(structures)):
if structures['length'][n] >= min_length and structures['length'][
n] <= max_length:
x_linspace = np.linspace(structures['length'][n],
max(profile.length.tolist()))
y = structures['slope'][n] * (x_linspace - structures['length'][n]
) + structures['elevation'][n]
if n > 0:
sep = structures['length'][n] - structures['length'][n - 1]
else:
sep = 0
plt.plot(x_linspace, y, 'r')
if id_measurements == True:
site_name = str(structures['id'][n])
plt.text(x_linspace[0],
y[0],
site_name,
bbox=dict(facecolor='white', edgecolor='white'),
horizontalalignment='center')
dip_d_angle = calc_dip_trend_diff(calc_cs_trend(profile),
structures['dip_d'][n])
extrap_strat = strat
strat += sep * np.cos(np.deg2rad(dip_d_angle)) * np.sin(
np.deg2rad(abs(structures['dip'][n])))
lab_height = (ylim - max(y)) * (0.1 + 0.1 *
(n % 6)) #(30 + (n * 10)%60)*
plt.text(structures['length'][n],
max(y) + lab_height,
'{0}'.format(int(strat)),
horizontalalignment='center')
plt.vlines(structures['length'][n],
structures['elevation'][n],
max(y) + lab_height - 4,
linestyles='dotted')
if contacts:
for contact in contacts:
if n == 0:
contact_strat[contact] = extrap_strat + (
contacts[contact] - structures['length'][n]
) * np.sin(np.deg2rad(abs(structures['corr_dip'][n])))
elif contacts[contact] <= structures['length'][
n] and contacts[contact] >= structures['length'][
n - 1]:
contact_strat[contact] = extrap_strat + (
contacts[contact] -
structures['length'][n - 1]) * np.sin(
np.deg2rad(abs(structures['corr_dip'][n - 1])))
if n > 0 and n < len(structures) - 1:
if structures['length'][n] - structures['length'][
n - 1] > extrap_range:
for extrap in range(
int(structures['length'][n - 1]) + extrap_range,
int(structures['length'][n]), extrap_range):
extrap_strat += extrap_range * np.cos(
np.deg2rad(dip_d_angle)) * np.sin(
np.deg2rad(abs(structures['dip'][n - 1])))
text_height = 30 + (extrap * 10) % 60
plt.text(extrap,
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'] +
text_height,
'{0}'.format(int(extrap_strat)),
horizontalalignment='center')
plt.vlines(
extrap,
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'],
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'] +
text_height - 5,
linestyles='dotted')
elif n == len(structures) - 1:
if max_length - structures['length'][n] > extrap_range:
extrap_strat = strat
for extrap in range(
int(structures['length'][n]) + extrap_range,
max_length, extrap_range):
extrap_strat += extrap_range * np.cos(
np.deg2rad(dip_d_angle)) * np.sin(
np.deg2rad(abs(structures['dip'][n])))
text_height = 30 + (extrap * 10) % 60
plt.text(extrap,
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'] +
text_height,
'{0}'.format(int(extrap_strat)),
horizontalalignment='center')
plt.vlines(
extrap,
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'],
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'] +
text_height - 5,
linestyles='dotted')
extrap = int(max(profile.length))
total_strat = extrap_strat + extrap_range * np.cos(
np.deg2rad(dip_d_angle)) * np.sin(
np.deg2rad(abs(structures['dip'][n])))
elif n == 0:
if structures['length'][n] > extrap_range:
for extrap in range(
int(min(structures.length)) - extrap_range,
min_length, -extrap_range):
extrap_strat += -extrap_range * np.cos(
np.deg2rad(dip_d_angle)) * np.sin(
np.deg2rad(abs(structures['dip'][0])))
text_height = 30 + (extrap * 10) % 60
plt.text(extrap,
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'] +
text_height,
'{0}'.format(int(extrap_strat)),
horizontalalignment='center')
plt.vlines(
extrap,
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'],
profile.loc[profile['length'] == find_nearest(
profile['length'], extrap)]['elevation'] +
text_height - 5,
linestyles='dotted')
if contacts:
for contact in contacts:
xline = float(contacts[contact])
ymax = profile.loc[profile['length'] == find_nearest(
profile['length'], xline)]['elevation']
plt.vlines(xline,
0,
float(ymax),
colors=np.random.rand(3),
linewidth=3.0,
linestyles='dotted',
label=contact)
y_place = np.random.randint(ymax + 0.1 * (ylim - ymin),
ylim - 0.1 * (ylim - ymin))
plt.text(xline,
y_place + 5,
'{0}'.format(int(contact_strat[contact])),
color='g',
horizontalalignment='center')
plt.vlines(xline, ymax, y_place, linestyles='dotted')
if locations:
for location in locations:
y_rng = []
x_rng = np.linspace(locations[location][0], locations[location][1])
for x in x_rng:
y_rng.append(
float(profile.loc[profile['length'] == find_nearest(
profile['length'], x)]['elevation']))
vertices = [(x_rng[0], 0)] + list(zip(x_rng,
y_rng)) + [(x_rng[-1], 0)]
poly = Polygon(vertices,
facecolor='r',
alpha=0.4,
edgecolor='none',
label=location)
plt.gca().add_patch(poly)
ax4.text(0,
1,
'{:.5}\n{:.5}'.format(profile['lat'][min_ind],
profile['lon'][min_ind]),
color='r',
transform=ax4.transAxes,
bbox=dict(facecolor='white', edgecolor='white'),
verticalalignment='top',
zorder=50)
ax4.text(1,
1,
'{:.5}\n{:.5}'.format(profile['lat'][max_ind],
profile['lon'][max_ind]),
color='r',
transform=ax4.transAxes,
bbox=dict(facecolor='white', edgecolor='white'),
verticalalignment='top',
zorder=50)
plt.xlabel('meters')
plt.ylabel('meters')
plt.xlim(min_length, max_length)
plt.ylim(ymin, ylim)
plt.title('Bearing = {:.4}°, Total Strat = {:.4} km'.format(
calc_cs_trend(profile), total_strat / 1000))
if save == True:
plt.savefig(str(save_name))
plt.legend()
plt.show()
def metpyplot(shpFiles, lonlat, mLon, mLat, mTem):
# 初始化
#绘图参数设置
isStationInfoOn = False #站点信息是否标注
isaxInfoOn = False # 坐标轴信息是否标注
cmap = cmaps.BlAqGrYeOrReVi200 #色标选择 http://www.ncl.ucar.edu/Document/Graphics/color_table_gallery.shtml 参考该网址 MPL_YlOrRd amwg256
legendRange = [int(min(mTem)), math.ceil(max(mTem))]
fbl = 0.05 #克里金插值空间分辨率
sebiaoNums = 15 #色标个数
picTitle = 'Temperature'
zuobiaoSetInter = 0.5 #坐标轴经纬度间隔设置
# shpPath=r'./shp/TJ/'
# shpName='TJ_all'
## bjName='TJ_bj'
shpFile = shpFiles[0]
# bjshp=shpPath+bjName
#天津经纬度范围设置
# llat=38.5
# ulat=40.3
# llon=116.7
# ulon=118.05
llon = lonlat[0]
ulon = lonlat[1]
llat = lonlat[2]
ulat = lonlat[3]
# fig=plt.figure(figsize=(16,9))
plt.rc('font', size=15, weight='bold')
# ax=fig.add_subplot(111)
# 底图读取及地图设置
m=Basemap(llcrnrlon=llon,llcrnrlat=llat,urcrnrlon=ulon,urcrnrlat=ulat,\
projection='cyl',resolution='c') # 等距投影
m.readshapefile(shpFile, 'Name', linewidth=1, color='k')
# 绘制经纬线
parallels = np.arange(llat, ulat, 0.5)
m.drawparallels(parallels, labels=[1, 0, 0, 0], fontsize=10) # 绘制纬线
meridians = np.arange(llon, ulon, 0.5)
m.drawmeridians(meridians, labels=[0, 0, 0, 1], fontsize=10) # 绘制经线
# 坐标系经纬度转换
xllon, yllat = m(llon, llat)
xulon, yulat = m(ulon, ulat)
xmLon, ymLat = m(mLon, mLat)
# meshgrid set the grid range
gridx = np.arange(xllon, xulon, fbl)
gridy = np.arange(yllat, yulat, fbl)
Xlon, Ylat = np.meshgrid(gridx, gridy)
#插值处理
# OK=OrdinaryKriging(xmLon,ymLat,mTem,variogram_model='linear',
# verbose=False,enable_plotting=False)
# z,ss=OK.execute('grid',gridx,gridy)
gx, gy, img = interpolate(xmLon, ymLat, mTem, \
interp_type='linear', hres=fbl)
levels = np.linspace(legendRange[0], legendRange[1], sebiaoNums)
cs = m.contourf(gx, gy, img, levels, cmap=cmap)
m.colorbar(cs)
# cf=m.contourf(Xlon,Ylat,z,levels=levels,cmap=cmap)
# m.colorbar(cf,location='right',format='%.1f',size=0.3,\
# ticks=np.linspace(legendRange[0],legendRange[1],sebiaoNums),label='单位：℃')
#
# 添加站名信息
if isStationInfoOn == True:
m.scatter(xmLon, ymLat, c='k', s=10, marker='o')
for i in range(0, len(xmLon)):
# pass
plt.text(xmLon[i],
ymLat[i],
stationName[i],
va='bottom',
fontsize=12)
# plt.text(xmLon[i],ymLat[i],mTem[i],va='top',fontsize=12)
plt.title(picTitle)
# 坐标轴标注
if isaxInfoOn == True:
lon_label = []
lat_label = []
lon_num = np.arange(xllon, xulon, zuobiaoSetInter)
for lon in lon_num:
lon_label.append(str(lon) + '°E')
lat_num = np.arange(yllat, yulat, zuobiaoSetInter)
for lat in lat_num:
lat_label.append(str(lat) + '°N')
plt.yticks(lat_num, lat_label)
plt.xticks(lon_num, lon_label)
# 白化
# maskout.shp2clip(cf,ax,bjshp,0.005588) #0.005588为gis图周长信息
# picture introduction
plt.show()
def run(FILE_NAME):
GEO_FILE_NAME = 'MYD03.A2002226.0000.005.2009193071127.hdf'
GEO_FILE_NAME = os.path.join(os.environ['HDFEOS_ZOO_DIR'], GEO_FILE_NAME)
DATAFIELD_NAME = 'EV_1KM_Emissive'
if USE_NETCDF4:
from netCDF4 import Dataset
nc = Dataset(FILE_NAME)
# Just read the first level, Band 20.
# lat/lon resolution.
data = nc.variables[DATAFIELD_NAME][0, :, :].astype(np.float64)
# Retrieve the geolocation data from MYD03 product.
nc_geo = Dataset(GEO_FILE_NAME)
longitude = nc_geo.variables['Longitude'][:]
latitude = nc_geo.variables['Latitude'][:]
# Retrieve attributes.
units = nc.variables[DATAFIELD_NAME].radiance_units
long_name = nc.variables[DATAFIELD_NAME].long_name
# The scale and offset attributes do not have standard names in this
# case, so we have to apply the scaling equation ourselves.
scale_factor = nc.variables[DATAFIELD_NAME].radiance_scales[0]
add_offset = nc.variables[DATAFIELD_NAME].radiance_offsets[0]
valid_range = nc.variables[DATAFIELD_NAME].valid_range
_FillValue = nc.variables[DATAFIELD_NAME]._FillValue
valid_min = valid_range[0]
valid_max = valid_range[1]
# Retrieve dimension name.
dimname = nc.variables[DATAFIELD_NAME].dimensions[0]
else:
from pyhdf.SD import SD, SDC
hdf = SD(FILE_NAME, SDC.READ)
# Read dataset.
data3D = hdf.select(DATAFIELD_NAME)
data = data3D[0, :, :].astype(np.double)
hdf_geo = SD(GEO_FILE_NAME, SDC.READ)
# Read geolocation dataset from MOD03 product.
lat = hdf_geo.select('Latitude')
latitude = lat[:, :]
lon = hdf_geo.select('Longitude')
longitude = lon[:, :]
# Retrieve attributes.
attrs = data3D.attributes(full=1)
lna = attrs["long_name"]
long_name = lna[0]
aoa = attrs["radiance_offsets"]
add_offset = aoa[0][0]
fva = attrs["_FillValue"]
_FillValue = fva[0]
sfa = attrs["radiance_scales"]
scale_factor = sfa[0][0]
vra = attrs["valid_range"]
valid_min = vra[0][0]
valid_max = vra[0][1]
ua = attrs["radiance_units"]
units = ua[0]
# Retrieve dimension name.
dim = data3D.dim(0)
dimname = dim.info()[0]
invalid = np.logical_or(data > valid_max, data < valid_min)
invalid = np.logical_or(invalid, data == _FillValue)
data[invalid] = np.nan
data = (data - add_offset) * scale_factor
data = np.ma.masked_array(data, np.isnan(data))
# The data is close to the equator in Africa, so a global projection is
# not needed.
m = Basemap(projection='cyl',
resolution='l',
llcrnrlat=-5,
urcrnrlat=30,
llcrnrlon=5,
urcrnrlon=45)
m.drawcoastlines(linewidth=0.5)
m.drawparallels(np.arange(0, 50, 10), labels=[1, 0, 0, 0])
m.drawmeridians(np.arange(0, 50., 10), labels=[0, 0, 0, 1])
m.pcolormesh(longitude, latitude, data, latlon=True)
cb = m.colorbar()
cb.set_label(units, fontsize=8)
basename = os.path.basename(FILE_NAME)
plt.title('{0}\n{1}\nat {2}=0'.format(basename,
'Radiance derived from ' + long_name,
dimname),
fontsize=11)
fig = plt.gcf()
# plt.show()
pngfile = "{0}.py.png".format(basename)
fig.savefig(pngfile)
#Plot data on the map
print('='*80)
print(datetime.now(), proc_start_date, '-', proc_end_date, 'Plotting data on the map')
plt.figure(figsize=(10, 10))
# sylender map
m = Basemap(projection='cyl', resolution='h', \
llcrnrlat = Slat, urcrnrlat = Nlat, \
llcrnrlon = Llon, urcrnrlon = Rlon)
m.drawcoastlines(linewidth=0.25)
m.drawcountries(linewidth=0.25)
#m.fillcontinents(color='coral',lake_color='aqua')
#m.drawmapboundary(fill_color='aqua')
m.drawparallels(np.arange(-90., 90., 10.), labels=[1, 0, 0, 0])
m.drawmeridians(np.arange(-180., 181., 15.), labels=[0, 0, 0, 1])
x, y = m(lon_array, lat_array) # convert to projection map
plt.pcolormesh(x, y, mean_array)
plt.colorbar(cmap='bwr', fraction=0.038, pad=0.04)
plt.title('MODIS AOD', fontsize=20)
plt.savefig(save_dir_name+'_'+proc_start_date+'-'+proc_end_date+'.png', bbox_inches='tight', dpi = 300)
working_time = (datetime.now() - cht_start_time) #total days for downloading
print(datetime.now(), proc_start_date, '-', proc_end_date, 'Map(image) is created ')
add_log.write('%s: %s-%s Map(image) is created...\n' % (datetime.now(), proc_start_date, proc_end_date))
print(datetime.now(), 'working time (sec) :', working_time)
print('='*80)
import matplotlib.pyplot as plt
import numpy as np
# set up orthographic map projection with
# perspective of satellite looking down at 50N, 100W.
# use low resolution coastlines.
map = Basemap(projection='merc', llcrnrlat=-50, urcrnrlat=50,
llcrnrlon=-180, urcrnrlon=180, resolution='i')
# draw coastlines, country boundaries, fill continents.
map.drawcoastlines(linewidth=0.25)
map.drawcountries(linewidth=0.25)
map.fillcontinents(color='coral',lake_color='aqua')
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary(fill_color='aqua')
# draw lat/lon grid lines every 30 degrees.
map.drawmeridians(np.arange(0,360,30))
map.drawparallels(np.arange(-90,90,30))
# make up some data on a regular lat/lon grid.
nlats = 73; nlons = 145; delta = 2.*np.pi/(nlons-1)
lats = (0.5*np.pi-delta*np.indices((nlats,nlons))[0,:,:])
lons = (delta*np.indices((nlats,nlons))[1,:,:])
print(lons)
print(lons.shape)
wave = 0.75*(np.sin(2.*lats)**8*np.cos(4.*lons))
mean = 0.5*np.cos(2.*lats)*((np.sin(2.*lats))**2 + 2.)
# compute native map projection coordinates of lat/lon grid.
x, y = map(lons*180./np.pi, lats*180./np.pi)
parallel_steps = [44, 44.5, 45, 45.5]
plt.figure(figsize=(10, 10))
# chl
ax = plt.subplot(2, 2, 1)
ax.set_title('Chl')
current_cmap = plt.cm.get_cmap()
current_cmap.set_bad(color='white')
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')
m = Basemap(projection='merc',
urcrnrlat=limits[1],
urcrnrlon=limits[3],
llcrnrlat=limits[0],
llcrnrlon=limits[2])
m.drawcoastlines()
m.drawstates()
m.drawmeridians(lon,
labels=[0, 0, 0, 1],
fontsize=10,
linewidth=1,
dashes=(None, None),
size=12)
m.drawparallels(lat,
labels=[1, 0, 0, 0],
fontsize=10,
linewidth=1,
dashes=(None, None),
size=12)
#xi, yi = m(lo, la)
#m.pcolormesh(xi, yi, t2[0, :,:], edgecolor='Black', linewidth= 0.25,
# cmap='Blues', alpha = 0.2)
xa, ya = m(pin_df.xa.values, pin_df.ya.values)
xb, yb = m(pin_df.xb.values, pin_df.yb.values)
pts = np.c_[xa, ya, xb, yb].reshape(len(xa), 2, 2)
plt.gca().add_collection(LineCollection(pts, color='crimson', label='streets'))
xx, yy = m(pin_est[1], pin_est[0])
m.plot(xx,
yy,
marker="o",
ls="",
label="Pinheiros",
# ### Plotting data on a map (Example Gallery) https://matplotlib.org/basemap/users/examples.html # # # # In[76]: ### PLOT FIGURE fig = plt.figure(figsize=(20,16)) ax = fig.add_subplot(1,1,1) ### Draw Latitude Lines m.drawparallels(np.arange(-90.,120.,10.),labels=[1,0,0,0],fontsize=20,linewidth=0.2) ### Draw Longitude Lines m.drawmeridians(np.arange(-180.,180.,10.),labels=[0,0,0,1],fontsize=20,linewidth=0.2) ### Draw Map m.drawcoastlines() m.drawmapboundary() m.drawcountries() ### Plot contour lines for pot. temp and fill levels = np.arange(258,390,6) cmap = colors.ListedColormap([no1, no2, no3, no4, no5, no6, no7, no8, no9, no10, no11, no12, no13, no14, no15, no16, no17, no18, no19, no20, no21])
# lonlat, lonlon are lat/lon of London.
lonlat = 51.53
lonlon = 0.08
# find 1000 points along the great circle.
#x,y = m.gcpoints(nylon,nylat,lonlon,lonlat,1000)
# draw the great circle.
#m.plot(x,y,linewidth=2)
# drawgreatcircle performs the previous 2 steps in one call.
m.drawgreatcircle(nylon, nylat, lonlon, lonlat, linewidth=2, color='b')
m.drawcoastlines()
m.fillcontinents()
# draw parallels
circles = np.arange(10, 90, 20)
m.drawparallels(circles, labels=[1, 1, 0, 1])
# draw meridians
meridians = np.arange(-180, 180, 30)
m.drawmeridians(meridians, labels=[1, 1, 0, 1])
plt.title('Great Circle from New York to London (Mercator)')
sys.stdout.write('plotting Great Circle from New York to London (Mercator)\n')
# create new figure
fig = plt.figure()
# setup a gnomonic projection.
m = Basemap(llcrnrlon=-100.,llcrnrlat=20.,urcrnrlon=20.,urcrnrlat=60.,\
resolution='c',area_thresh=10000.,projection='gnom',\
lat_0=40.,lon_0=-45.)
# nylat, nylon are lat/lon of New York
nylat = 40.78
nylon = -73.98
def plot_map(self, var1d, lats, lons, sites, plot_name, title, yr):
from matplotlib.font_manager import FontProperties
fp = FontProperties(fname=r'C:\WINDOWS\Fonts\msgothic.ttc', size=5)
# --- Build Map ---
fig = plt.figure()
plt.rc('font', family='serif')
my_cmap = plt.get_cmap('rainbow')
font_size = 10
# --- limits
map_lims = self.map_lims
# --- map labels ---
mp = Basemap(projection='gall',
llcrnrlat=map_lims[0],
urcrnrlat=map_lims[1],
llcrnrlon=map_lims[2],
urcrnrlon=map_lims[3],
resolution='l')
mp.drawcoastlines(color='grey')
mp.drawcountries(color='grey')
mp.drawparallels(np.arange(-90, 91, map_lims[4]),
labels=[True, False, True, False],
fontsize=font_size,
color='grey')
mp.drawmeridians(np.arange(2, 362, map_lims[5]),
labels=[False, True, False, True],
fontsize=font_size,
color='grey')
x, y = mp(lons, lats)
mp.scatter(x, y, c=var1d, s=10, cmap=my_cmap)
# --- selected sites
o_site = ''
for j in range(0, len(sites), 1):
n_lat = lats[j]
n_lon = lons[j]
n_site = sites[j]
# --- plot only unploted sites
# if n_site != o_site:
if n_site[:1] != o_site[:1]:
x, y = mp(n_lon, n_lat)
plt.text(x,
y,
n_site,
color='k',
weight='bold',
fontsize=font_size - 6,
fontproperties=fp)
o_site = sites[j]
# --- title
plt.title(title + ' for ' + yr)
# --- legend
# plt.legend(loc="lower left", ncol=4, prop={'size': font_size - 4}, fancybox=True, shadow=True)
plt.colorbar()
# --- save to plot
a_saveplot.save_plot(plot_name, ext="png", close=True, verbose=False)
plt.show()
lat = HEAT_data.variables['lat'][:]
temp = HEAT_data.variables['TEMP'][:]
HEAT_data.close()
lon, temp = PeriodicBoundaries(lon, lat, temp)
#-----------------------------------------------------------------------------------------
fig, ax = subplots()
m = Basemap(projection='spstere',boundinglat=-60,lon_0=180,resolution='i', area_thresh=0.01)
m.drawcoastlines(linewidth=0.5)
m.drawcountries()
m.fillcontinents(color='#cc9966',lake_color='#99ffff')
m.drawmapboundary(fill_color='azure')
m.drawparallels(np.arange(-80,81,20),labels=[0,0,0,0])
m.drawmeridians(np.arange(-180,180,30),labels=[1,0,0,1])
x, y = np.meshgrid(lon, lat)
x, y = m(x, y)
CS = m.contourf(x, y, temp, levels = np.arange(-3, 3.01, 0.2), extend = 'both', cmap = 'RdBu_r')
cbar = m.colorbar(CS, ticks = np.arange(-3, 3.01, 1))
cbar.set_label('Temperature difference ($^{\circ}$C)')
ax.set_title('e) HR-CESM Control minus Mercator')
show()
def PlotMap(Hydr, MapLabels=True, Savefig=False, Figpath=False, Form='jpg'):
"""
PlotMap
PlotMap plots station locations on a map.
Input: TripNo, Hydr, MapLabels (station labels, default = True)
Output: None
"""
# INITIATING FIGURE
fig, ax = plt.subplots(figsize=(10, 12))
# BASEMAP PROJECTION
# find data lon, lat bounds and round to pretty numbers
lonmin, latmin = Hydr[['Lon', 'Lat']].min()
lonmax, latmax = Hydr[['Lon', 'Lat']].max()
lonmin, latmin = varmin(lonmin - 0.005, a=100), varmin(latmin - 0.005,
a=100)
lonmax, latmax = varmax(lonmax + 0.005, a=100), varmax(latmax + 0.005,
a=100)
m = Basemap(projection='merc',
resolution=None,
llcrnrlat=latmin,
urcrnrlat=latmax,
llcrnrlon=lonmin,
urcrnrlon=lonmax)
# Draw islands from txt file and fill.
for island in os.listdir('Coasts'):
lon, aa, lat = np.genfromtxt('Coasts/' + island, delimiter=' ').T
xpt, ypt = m(lon, lat)
m.plot(xpt, ypt, 'black', linewidth=1)
plt.fill(xpt, ypt, 'tan')
# PLOTTING STATIONS INTO MAP
for lon, lat, name in zip(Hydr.Lon, Hydr.Lat, Hydr.StName):
xpt, ypt = m(lon, lat)
m.plot(xpt, ypt, 'bo', markersize=9)
# setting labels if requested
if MapLabels == True:
xp, yp = m(Hydr.Lon.mean(), Hydr.Lat.mean())
xoffset, yoffset = 0.05 * xp, 0.05 * xp
ax.text(xpt - xoffset, ypt + yoffset, name, fontsize=12)
#plt.text(xpt - xoffset, ypt + yoffset, name, fontsize = 9)
#plt.title('{}'.format(MapName), fontsize=14)
ax.set_title('CTD stations - {}'.format(Hydr.Date.iloc[0]), fontsize=20)
# Draw meridional and zonal lines
# define gap between thick and thin lines depending on map wiev
if (latmax - latmin) > 0.05:
dlat, dlon, ddlat, ddlon = 0.1, 0.05, False, False
elif (latmax - latmin) <= 0.05:
dlat, dlon, ddlat, ddlon = 0.05, 0.02, 0.01, 0.01
# draw thick lines
parallels = np.arange(varmin(latmin, a=20), varmax(latmax, a=20), dlon)
meridians = np.arange(varmin(lonmin, a=20), varmax(lonmax, a=20), dlat)
m.drawparallels(parallels, labels=[1, 0, 0, 0], linewidth=0.5, color='k')
m.drawmeridians(meridians, labels=[0, 0, 0, 1], linewidth=0.5, color='k')
# draw thin lines
if ddlat:
parallels = np.arange(latmin, latmax, ddlon)
meridians = np.arange(lonmin, lonmax, ddlat)
m.drawparallels(parallels,
labels=[1, 0, 0, 0],
linewidth=0.2,
color='k')
m.drawmeridians(meridians,
labels=[0, 0, 0, 1],
linewidth=0.2,
color='k')
if Savefig:
path = Figpath + 'map.{}'.format(Form)
fig.savefig(path, format=Form, dpi=400, bbox_inches='tight')
# illustrate use of warpimage method to display an image background
# on the map projection region. Default background is the 'blue
# marble' image from NASA (http://visibleearth.nasa.gov).
# create new figure
fig=plt.figure()
# define orthographic projection centered on North America.
m = Basemap(projection='ortho',lat_0=40,lon_0=-100,resolution='l')
# display a non-default image.
m.warpimage(image='earth_lights_lrg.jpg')
# draw coastlines.
m.drawcoastlines(linewidth=0.5,color='0.5')
# draw lat/lon grid lines every 30 degrees.
m.drawmeridians(np.arange(0,360,30),color='0.5')
m.drawparallels(np.arange(-90,90,30),color='0.5')
plt.title("Lights at Night image warped from 'cyl' to 'ortho' projection",fontsize=12)
print('warp to orthographic map ...')
# create new figure
fig=plt.figure()
# define projection centered on North America.
m = Basemap(projection='mbtfpq',lon_0=-100,resolution='l')
m.bluemarble(scale=0.5)
# draw coastlines.
m.drawcoastlines(linewidth=0.5,color='0.5')
# draw lat/lon grid lines every 30 degrees.
m.drawmeridians(np.arange(0,360,60),color='0.5')
m.drawparallels(np.arange(-90,90,30),color='0.5')
plt.title("Blue Marble image warped from 'cyl' to 'mbtfpq' projection",fontsize=12)
print('warp to McBryde-Thomas Flat-Polar Quartic map ...')
A2 = pd.read_csv(area2_file, delimiter=r",") ## ---- Plot Climato ---- ## fig, ax = plt.subplots(nrows=1, ncols=1) m = Basemap(ax=ax, projection='merc',lon_0=lon_0,lat_0=lat_0, llcrnrlon=lonLims[0],llcrnrlat=latLims[0],urcrnrlon=lonLims[1],urcrnrlat=latLims[1], resolution= 'i') #levels = np.linspace(-2, 6, 9) levels = np.linspace(-2, 6, 17) xi, yi = m(*np.meshgrid(lon_reg, lat_reg)) c = m.contourf(xi, yi, Tbot_climato, levels, cmap=plt.cm.RdBu_r, extend='both') cc = m.contour(xi, yi, -Zitp, [100, 500, 1000, 4000], colors='grey'); #c = m.pcolormesh(xi,yi,Tbot_climato, clim=[-2,6], cmap=plt.cm.RdBu_r) #c = m.pcolormesh(xi,yi,Tbot_climato, clim=[-2,6], cmap=cmocean.cm.thermal) c.set_clim(-2,6) plt.clabel(cc, inline=1, fontsize=10, fmt='%d') m.fillcontinents(color='tan'); m.drawparallels([54, 55, 56, 57, 58, 59], labels=[1,0,0,0], fontsize=12, fontweight='normal'); m.drawmeridians([-62, -60, -58, -56], labels=[0,0,0,1], fontsize=12, fontweight='normal'); # plot casts x, y = m(lon_orig, lat_orig) m.scatter(x,y, s=50, marker='.',color='k') # plot areas #x, y = m(A1.long_dd.values, A1.lat_dd.values) #m.plot(x,y, '-k', linewidth=3) #x, y = m(-63, 57.1) #plt.text(x, y, ' Area 1', fontsize=12, fontweight='bold') #x, y = m(A2.long_dd.values, A2.lat_dd.values) #m.plot(x,y, '-k', linewidth=3) #x, y = m(-60, 54.5) #plt.text(x, y, ' Area 2', fontsize=12, fontweight='bold') m.fillcontinents(color='tan');
