# example demonstrating how to draw a great circle on a map.
from matplotlib.toolkits.basemap import Basemap
from pylab import *
# setup lambert azimuthal map projection.
m = Basemap(-100.,20.,20.,60.,
resolution='c',area_thresh=10000.,projection='merc',\
lat_0=40.,lon_0=-20.,lat_ts=20.)
# make figure with aspect ratio that matches map region.
xsize = rcParams['figure.figsize'][0]
fig = figure(figsize=(xsize, m.aspect * xsize))
fig.add_axes([0.1, 0.1, 0.8, 0.8])
# nylat, nylon are lat/lon of New York
nylat = 40.78
nylon = -73.98
# 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 = arange(10, 90, 20)
m.drawparallels(circles, labels=[1, 1, 0, 1])
# draw meridians
meridians = arange(-180, 180, 30)
def draw_client_density():
m = Basemap(llcrnrlon=-180.,llcrnrlat=-90,urcrnrlon=180.,urcrnrlat=90.,\
resolution='c',projection='cyl')
# plot them as filled circles on the map.
# first, create a figure.
dpi=100
dimx=800/dpi
dimy=400/dpi
fig=figure(figsize=(dimx,dimy), dpi=dpi, frameon=False, facecolor='blue')
# ax=fig.add_axes([0.1,0.1,0.7,0.7],axisbg='g')
ax=fig.add_axes([0.0,0.0,1.0,1.0],axisbg='g')
canvas = FigureCanvas(fig)
results = lookup_client_locations()
X,Y,Z = find_client_density(m,results)
# s = random.sample(results, 40000)
# for t in s:
# lat=t[2]
# lon=t[3]
# # draw a red dot at the center.
# xpt, ypt = m(lon, lat)
# m.plot([xpt],[ypt],'ro', zorder=10)
# draw coasts and fill continents.
m.drawcoastlines(linewidth=0.5)
m.drawcountries(linewidth=0.5)
m.drawlsmask([100,100,100,0],[0,0,255,255])
# m.fillcontinents(color='green')
palette = cm.YlOrRd
m.imshow(Z,palette,extent=(m.xmin,m.xmax,m.ymin,m.ymax),interpolation='gaussian',zorder=0)
# l,b,w,h = ax.get_position()
# cax = axes([l+w+0.075, b, 0.05, h])
# colorbar(cax=cax) # draw colorbar
canvas.print_figure(outdir+'/clientmap.png', dpi=100)
def InvokeMap(coastfile='/media/sda4/map-data/aust-coast-noaa-2000000-1.dat',
lllon=80,
urlon=166,
lllat=-47,
urlat=-9,
draw_map=True):
global PYLIB_PATH
map = Basemap(projection='cyl',
llcrnrlon=lllon,
urcrnrlon=urlon,
llcrnrlat=lllat,
urcrnrlat=urlat,
#lat_ts=-35,
lat_0=-35,
lon_0=120,
resolution='l',
area_thresh=1000.)
try:
coast = p.load(coastfile)
coast = p.load(coastfile)
coast_x,coast_y = map(coast[:,0],coast[:,1])
p.plot(coast_x,coast_y,color='black')
except IOError:
map.drawcoastlines()
map.drawmapboundary()
map.drawmeridians(p.arange(0,360,10),labels=[0,0,1,0])
map.drawparallels(p.arange(-90,0,10),labels=[1,0,0,0])
return map
def doit():
map = Basemap(projection='lcc',
llcrnrlon=80,
urcrnrlon=160,
llcrnrlat=-50,
urcrnrlat=-8,
#lat_ts=-35,
lat_0=-35,
lon_0=120,
resolution='c',
area_thresh=1000.)
p.clf()
map.drawcoastlines()
# map.drawcountries()
# map.drawrivers()
map.drawmeridians(p.arange(0,360,10),labels=[0,0,1,0])
map.drawparallels(p.arange(-90,0,10),labels=[1,0,0,0])
traj=p.load('example_traj.dat')
coast=p.load('/media/sda4/map-data/aust-coast-noaa-2000000-1.dat')
traj_x,traj_y = map(traj[:,1],traj[:,0])
# coast_x,coast_y = map(coast[:,0],coast[:,1])
p.plot(traj_x,traj_y)
p.plot(coast_x,coast_y,color='black')
map.drawmapboundary()
p.show()
return map
def set_default_basemap(lon, lat, frame_width=5.):
test = lon < 0.
if True in test:
# matplotlib expects 0-360 while WRF for example uses -180-180
delta = n.ones(lon.shape)
delta *= 360
delta = ma.masked_where(lon > 0., delta)
lon += delta.filled(fill_value=0)
llcrnrlon=lon.min() - frame_width
urcrnrlon=lon.max() + frame_width
llcrnrlat=lat.min() - frame_width
urcrnrlat=lat.max() + frame_width
lon_0 = llcrnrlon + (urcrnrlon - llcrnrlon) / 2.
lat_0 = llcrnrlat + (urcrnrlat - llcrnrlat) / 2.
map = Basemap(
llcrnrlon=llcrnrlon,
llcrnrlat=llcrnrlat,
urcrnrlon=urcrnrlon,
urcrnrlat=urcrnrlat,
resolution='l',
projection='cyl',
lon_0=lon_0,
lat_0=lat_0
)
return map
def set_default_basemap(lon, lat):
map = Basemap(llcrnrlon=lon.min() - 0.5,
llcrnrlat=lat.min() - 0.5,
urcrnrlon=lon.max() + 0.5,
urcrnrlat=lat.max() + 0.5,
resolution='l',
projection='cyl',
lon_0=lon.min() + (lon.max() - lon.min()) / 2.,
lat_0=lat.min() + (lat.max() - lat.min()) / 2.)
return map
import matplotlib
from matplotlib.toolkits.basemap import Basemap
from pylab import *
m = Basemap(-11.,51.,-5.,56.,
resolution='c',area_thresh=1000.,projection='cyl')
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
fig.add_axes([0.1,0.1,0.8,0.8])
ax = gca() # get current axis instance
ax.update_datalim(((m.llcrnrx, m.llcrnry),(m.urcrnrx,m.urcrnry)))
ax.set_xlim((m.llcrnrx, m.urcrnrx))
ax.set_ylim((m.llcrnry, m.urcrnry))
m.drawcoastlines(ax)
m.fillcontinents(ax)
# draw parallels
circles = arange(50,60,1).tolist()
m.drawparallels(ax,circles,labels=[1,1,1,1])
# draw meridians
meridians = arange(-12,0,1)
m.drawmeridians(ax,meridians,labels=[1,1,1,1])
title("Crude Res Coastlines ('c')",y=1.075)
show()
m = Basemap(-11.,51.,-5.,56.,
resolution='l',area_thresh=1000.,projection='cyl')
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
fig.add_axes([0.1,0.1,0.8,0.8])
ax = gca() # get current axis instance
ax.update_datalim(((m.llcrnrx, m.llcrnry),(m.urcrnrx,m.urcrnry)))
from pylab import *
import math, random
from matplotlib.toolkits.basemap import Basemap
from matplotlib.numerix.random_array import uniform
# Plot a bunch of randomly distributed points on the earth.
# set up stereographic map centered on N. Pole.
m = Basemap(lon_0=-105,boundinglat=30.,
resolution='l',area_thresh=10000.,projection='npstere')
# number of points to plot.
npts = 750
# generate random points on a sphere,
# so that every small area on the sphere is expected
# to have the same number of points.
# http://mathworld.wolfram.com/SpherePointPicking.html
try: # this works for numpy
u = uniform(0.,1.,size=npts)
v = uniform(0.,1.,size=npts)
z = uniform(0.,1.,size=npts)
except: # this works for Numeric/numarray
u = uniform(0.,1.,shape=npts)
v = uniform(0.,1.,shape=npts)
z = uniform(0.,1.,shape=npts)
lons = 360.*u
lats = (180./math.pi)*arccos(2*v-1) - 90.
# transform lons and lats to map coordinates.
x,y = m(lons,lats)
# plot them as filled circles on the map.
# first, create a figure.
fig=figure()
ul.append(float(l[0]))
vl.append(float(l[1]))
pl.append(float(l[2]))
u = reshape(array(ul, Float32), (nlats, nlons))
v = reshape(array(vl, Float32), (nlats, nlons))
p = reshape(array(pl, Float32), (nlats, nlons))
lats1 = -90. + dellat * arange(nlats)
lons1 = -180. + dellon * arange(nlons)
lons, lats = meshgrid(lons1, lats1)
# plot vectors in geographical (lat/lon) coordinates.
# north polar projection.
m = Basemap(lon_0=-135,
boundinglat=25,
resolution='c',
area_thresh=10000.,
projection='npstere')
# create a figure, add an axes.
fig = figure(figsize=(8, 8))
ax = fig.add_axes([0.1, 0.1, 0.7, 0.7])
# rotate wind vectors to map projection coordinates.
# (also compute native map projections coordinates of lat/lon grid)
# only do Northern Hemisphere.
urot, vrot, x, y = m.rotate_vector(u[36:, :],
v[36:, :],
lons[36:, :],
lats[36:, :],
returnxy=True)
# plot filled contours over map.
cs = m.contourf(x, y, p[36:, :], 15, cmap=cm.jet)
"""
draw Atlantic Hurricane Tracks for storms that reached Cat 4 or 5.
part of the track for which storm is cat 4 or 5 is shown red.
ESRI shapefile data from http://www.nationalatlas.gov/atlasftp.html
"""
import pylab as p
from matplotlib.toolkits.basemap import Basemap as Basemap
# Lambert Conformal Conic map.
m = Basemap(llcrnrlon=-100.,llcrnrlat=0.,urcrnrlon=-20.,urcrnrlat=57.,
projection='lcc',lat_1=20.,lat_2=40.,lon_0=-60.)
# make sure map has right aspect ratio.
fig=p.figure(figsize=(8,m.aspect*8))
fig.add_axes([0.1,0.1,0.8,0.8])
# read shapefile.
shp_info = m.readshapefile('huralll020','hurrtracks',drawbounds=False)
print shp_info
# find names of storms that reached Cat 4.
names = []
for shapedict in m.hurrtracks_info:
cat = shapedict['CATEGORY']
name = shapedict['NAME']
if cat in ['H4','H5'] and name not in names:
if name != 'NOT NAMED': names.append(name)
print names
print len(names)
# plot tracks of those storms.
for shapedict,shape in zip(m.hurrtracks_info,m.hurrtracks):
name = shapedict['NAME']
cat = shapedict['CATEGORY']
if name in names:
xx,yy = zip(*shape)
# read in topo data from pickle (on a regular lat/lon grid)
# longitudes go from 20 to 380.
topodict = cPickle.load(open('etopo20.pickle', 'rb'))
topoin = topodict['data']
lons = topodict['lons']
lats = topodict['lats']
# shift data so lons go from -180 to 180 instead of 20 to 380.
topoin, lons = shiftgrid(180., topoin, lons, start=False)
print 'min/max etopo20 data:'
print min(ravel(topoin)), max(ravel(topoin))
# setup cylindrical equidistant map projection (global domain).
m = Basemap(-180.,-90,180.,90.,\
resolution='c',area_thresh=10000.,projection='cyl')
# setup figure with same aspect ratio as map.
xsize = rcParams['figure.figsize'][0]
fig = figure(figsize=(xsize, m.aspect * xsize))
ax = fig.add_axes([0.1, 0.1, 0.75, 0.75])
# plot image over map.
im = m.imshow(topoin, cm.jet)
cax = axes([0.875, 0.1, 0.05, 0.75]) # setup colorbar axes.
colorbar(tickfmt='%d', cax=cax) # draw colorbar
axes(ax) # make the original axes current again
m.drawcoastlines()
#m.drawcountries()
#m.drawstates()
#m.fillcontinents()
# draw parallels
delat = 30.
pylab.clf()
b = 5.
# Plot the region surrounding the coastline rounded to the nearest 5 degree lat/lon.
lonmin = b*math.floor(min(lon)/b)
lonmax = b*math.ceil(max(lon)/b)
latmin = b*math.floor(min(lat)/b)
latmax = b*math.ceil(max(lat)/b)
meridian = (range(lonmin, lonmax+b, b))
parallel = (range(latmin, latmax+b, b))
prj = 'cyl'
res = 'i'
map = Basemap(projection=prj,
llcrnrlon=lonmin,
llcrnrlat=latmin,
urcrnrlon=lonmax,
urcrnrlat=latmax,
resolution=res)
map.plot(lon, lat, 'r-')
map.plot(lon, lat, 'k+')
fs = 10
pylab.text(115.9,-31.9, "Perth", fontsize=fs, ha='left', va='top')
pylab.text(114.1,-21.9, "Exmouth", fontsize=fs, ha='left', va='top')
pylab.text(118.5,-20.4, "Port Hedland", fontsize=fs, ha='left', va='top')
pylab.text(130.8,-12.6, "Darwin", fontsize=fs, ha='left', va='top')
pylab.text(145.75,-16.9, "Cairns", fontsize=fs, ha='right', va='top')
pylab.text(149.2,-21.2, "Mackay", fontsize=fs, ha='right', va='top')
pylab.text(153.0,-27.5, "Brisbane", fontsize=fs, ha='right', va='top')
from matplotlib.toolkits.basemap import Basemap
from pylab import title, show, arange
# create Basemap instance for Orthographic (satellite view) projection.
lon_0 = float(raw_input('enter reference longitude (lon_0):'))
lat_0 = float(raw_input('enter reference latitude (lat_0):'))
m = Basemap(projection='ortho', lon_0=lon_0, lat_0=lat_0)
# plot land-sea mask.
rgba_land = (0, 255, 0, 255) # land green.
rgba_ocean = (0, 0, 255, 255) # ocean blue.
# lakes=True means plot inland lakes with ocean color.
m.drawlsmask(rgba_land, rgba_ocean, lakes=True)
# draw parallels and meridians.
m.drawparallels(arange(-90., 120., 30.))
m.drawmeridians(arange(0., 420., 60.))
m.drawmapboundary()
title('Orthographic Map Centered on Lon=%s, Lat=%s' % (lon_0, lat_0))
show()
def DrawSiteNetwork(self, g, node_label2pos_counts,pic_area=[-180,-90,180,90], output_fname_prefix=None):
"""
2007-07-17
put ax.plot() right after Basemap() but after m.xxx() so that it'll zoom in
use 'g' in ax.plot(), otherwise, ax.plot() alternates all colors.
no parallels, no meridians
2007-08-29 copied from CreatePopulation.py and renamed from DrawStrainNetwork
"""
sys.stderr.write("Drawing Site Network...")
import pylab
from matplotlib.toolkits.basemap import Basemap
pylab.clf()
fig = pylab.figure()
fig.add_axes([0.05,0.05,0.9,0.9]) #[left, bottom, width, height]
m = Basemap(llcrnrlon=pic_area[0],llcrnrlat=pic_area[1],urcrnrlon=pic_area[2],urcrnrlat=pic_area[3],\
resolution='l',projection='mill')
ax=pylab.gca()
for e in g.edges():
lat1, lon1 = node_label2pos_counts[e[0]][0]
lat2, lon2 = node_label2pos_counts[e[1]][0]
x1, y1 = m(lon1, lat1)
x2, y2 = m(lon2, lat2)
ax.plot([x1,x2],[y1,y2], 'g', alpha=0.5, zorder=12)
#m.drawcoastlines()
m.drawparallels(pylab.arange(-90,90,30), labels=[1,1,0,1])
m.drawmeridians(pylab.arange(-180,180,30), labels=[1,1,0,1])
m.fillcontinents()
m.drawcountries()
m.drawstates()
pylab.title("Network of strains")
if output_fname_prefix:
pylab.savefig('%s_site_network.eps'%output_fname_prefix, dpi=300)
pylab.savefig('%s_site_network.svg'%output_fname_prefix, dpi=300)
pylab.savefig('%s_site_network.png'%output_fname_prefix, dpi=300)
del m, pylab, Basemap
sys.stderr.write("Done.\n")
from matplotlib.toolkits.basemap import Basemap, shiftgrid
from pylab import *
import cPickle
# read in topo data from pickle (on a regular lat/lon grid)
# longitudes go from 20 to 380.
topodict = cPickle.load(open('etopo20.pickle', 'rb'))
topoin = topodict['data']
lons = topodict['lons']
lats = topodict['lats']
# shift data so lons go from -180 to 180 instead of 20 to 380.
topoin, lons = shiftgrid(180., topoin, lons, start=False)
# setup of basemap ('lcc' = lambert conformal conic).
m = Basemap(-145.5,1.,-2.566,46.352,\
resolution='c',area_thresh=10000.,projection='lcc',\
lat_1=50.,lon_0=-107.)
# transform to nx x ny regularly spaced native projection grid
nx = int((m.xmax - m.xmin) / 40000.) + 1
ny = int((m.ymax - m.ymin) / 40000.) + 1
topodat, x, y = m.transform_scalar(topoin, lons, lats, nx, ny, returnxy=True)
# set up figure with same aspect ratio as map.
xsize = rcParams['figure.figsize'][0]
fig = figure(figsize=(xsize, m.aspect * xsize))
ax = fig.add_axes([0.1, 0.1, 0.7, 0.7])
# plot image over map with imshow.
im = m.imshow(topodat, cm.jet)
# use pcolor (looks very similar to imshow, but slower).
#p = m.pcolor(x,y,topodat,shading='flat')
# plot contour lines over map (colors is a list so neg contours will
# not be dashed).
from matplotlib.toolkits.basemap import Basemap, interp
from pylab import *
import cPickle
# read in data on lat/lon grid.
datadict = cPickle.load(open('500hgt.pickle','rb'))
hgt = datadict['data']; lons = datadict['lons']; lats = datadict['lats']
# set up map projection (lambert azimuthal equal area).
m = Basemap(-150.,-20.,30.,-20.,
resolution='c',area_thresh=10000.,projection='laea',
lat_0=90.,lon_0=-105.)
# interpolate to map projection grid.
nx = 101
ny = 101
lonsout, latsout = m.makegrid(nx,ny)
# get rid of negative lons.
lonsout = where(lonsout < 0., lonsout + 360., lonsout)
hgt = interp(hgt,lons,lats,lonsout,latsout)
dx = (m.xmax-m.xmin)/(nx-1)
dy = (m.ymax-m.ymin)/(ny-1)
x = m.xmin+dx*indices((ny,nx))[1,:,:]
y = m.ymin+dy*indices((ny,nx))[0,:,:]
#m = Basemap(lons[0],lats[0],lons[-1],lats[-1],\
# resolution='c',area_thresh=10000.,projection='cyl')
#x, y = meshgrid(lons, lats)
fig = figure(figsize=(8,8))
plots = ['contour','pcolor']
# read in topo data from pickle (on a regular lat/lon grid)
# longitudes go from 20 to 380.
topodict = cPickle.load(open('etopo20.pickle', 'rb'))
topoin = topodict['data']
lons = topodict['lons']
lats = topodict['lats']
# shift data so lons go from 0 to 360 instead of 20 to 380.
topoin, lons = shiftgrid(360., topoin, lons, start=False)
print 'min/max etopo20 data:'
print min(ravel(topoin)), max(ravel(topoin))
m = Basemap(lons[0],lats[0],lons[-1],lats[-1],\
resolution='c',area_thresh=10000.,projection='cyl')
xsize = rcParams['figure.figsize'][0]
fig = figure(figsize=(xsize, m.aspect * xsize))
ax = fig.add_axes([0.1, 0.1, 0.75, 0.75])
im = imshow(topoin,
cm.jet,
extent=(m.llcrnrx, m.urcrnrx, m.llcrnry, m.urcrnry),
origin='lower')
cax = axes([0.875, 0.1, 0.05, 0.75])
colorbar(tickfmt='%d', cax=cax) # draw colorbar
axes(ax) # make the original axes current again
m.drawcoastlines(ax)
#m.drawcountries(ax)
#m.drawstates(ax)
#m.fillcontinents(ax)
# draw parallels
u1[:,-1] = u1_all[time_idx,:,0]
tmp = copy.copy(lon)
lon = p.zeros((p.size(tmp)+1,))
lon[0:-1] = tmp[:]
lon[-1] = tmp[0]+360
del tmp
f.close()
#--- Mapping information:
map = Basemap( projection='cyl', resolution='l'
, llcrnrlon=0, urcrnrlon=360
, llcrnrlat=-76.875, urcrnrlat=76.875
, lon_0=180, lat_0=0
)
map.drawmeridians(p.arange(0,361,45), labels=[0,0,0,1])
map.drawparallels(p.arange(-90,90,30), labels=[1,0,0,1])
map.drawcoastlines()
#--- Write out contour map and view using preview:
x, y = p.meshgrid(lon,lat)
CS = map.contourf(x, y, u1, cmap=p.cm.gray)
p.text( 0.5, -0.15, 'Longitude [deg]'
, horizontalalignment='center'
, verticalalignment='center'
, transform = p.gca().transAxes )
from matplotlib.toolkits.basemap import Basemap
from pylab import *
# read in topo data (on a regular lat/lon grid)
etopo = array(load('etopo20data.gz'), 'd')
lons = array(load('etopo20lons.gz'), 'd')
lats = array(load('etopo20lats.gz'), 'd')
# create Basemap instance for Robinson projection.
m = Basemap(projection='robin', lon_0=0.5 * (lons[0] + lons[-1]))
# create figure with same aspect ratio as map.
fig = m.createfigure()
# make filled contour plot.
x, y = m(*meshgrid(lons, lats))
cs = m.contourf(x, y, etopo, 30, cmap=cm.jet)
# draw coastlines.
m.drawcoastlines()
# draw a line around the map region.
m.drawmapboundary()
# draw parallels and meridians.
m.drawparallels(arange(-60., 90., 30.), labels=[1, 0, 0, 0])
m.drawmeridians(arange(0., 420., 60.), labels=[0, 0, 0, 1])
# add a title.
title('Robinson Projection')
show()
# make plot of etopo bathymetry/topography data on
# lambert conformal conic map projection, drawing coastlines, state and
# country boundaries, and parallels/meridians.
from matplotlib.toolkits.basemap import Basemap, interp
from pylab import *
import cPickle
# read in topo data from pickle (on a regular lat/lon grid)
# longitudes go from 20 to 380.
topodict = cPickle.load(open('data/etopo20.pickle','rb'))
topoin = topodict['data']; lons = topodict['lons']; lats = topodict['lats']
# setup of basemap ('lcc' = lambert conformal conic).
m = Basemap(-145.5,1.,-2.566,46.352,\
resolution='c',area_thresh=10000.,projection='lcc',\
lat_1=50.,lon_0=-107.)
# define grid (nx x ny regularly spaced native projection grid)
nx = int((m.xmax-m.xmin)/40000.)+1; ny = int((m.ymax-m.ymin)/40000.)+1
lonsout, latsout = m.makegrid(nx,ny)
topodat = interp(topoin,lons,lats,lonsout,latsout)
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
ax = fig.add_axes([0.1,0.1,0.75,0.75])
im = imshow(topodat,cm.jet,extent=(m.xmin, m.xmax, m.ymin, m.ymax),origin='lower')
cax = axes([0.875, 0.1, 0.05, 0.75])
colorbar(tickfmt='%d', cax=cax) # draw colorbar
axes(ax) # make the original axes current again
m.drawcoastlines(ax)
from matplotlib.toolkits.basemap import Basemap, basemap_datadir
from pylab import show, title, arange, figure, draw, ion, ioff, clf
import cPickle, time, sys, os
# turn interactive mode on.
ion()
# create new figure
fig = figure()
# create Basemap instance. Use 'crude' resolution coastlines.
m = Basemap(llcrnrlon=-11.,
llcrnrlat=50.5,
urcrnrlon=-5.,
urcrnrlat=56.,
resolution='c',
projection='tmerc',
lon_0=-8.,
lat_0=0.)
# draw coastlines and fill continents.
m.drawcoastlines()
m.fillcontinents()
# draw political boundaries.
m.drawcountries()
# draw parallels
circles = arange(50, 60, 1).tolist()
m.drawparallels(circles, labels=[1, 1, 0, 0])
# draw meridians
meridians = arange(-12, 0, 1)
m.drawmeridians(meridians, labels=[0, 0, 1, 1])
print 'plotting with crude res boundaries ...'
title("Crude Res Boundaries ('c')", y=1.05)
draw()
# country boundaries, and parallels/meridians.
from matplotlib.toolkits.basemap import Basemap, interp
from pylab import *
import cPickle
# read in topo data from pickle (on a regular lat/lon grid)
# longitudes go from 20 to 380.
topodict = cPickle.load(open('etopo20.pickle', 'rb'))
topoin = topodict['data']
lons = topodict['lons']
lats = topodict['lats']
# setup of basemap ('lcc' = lambert conformal conic).
m = Basemap(-145.5,1.,-2.566,46.352,\
resolution='c',area_thresh=10000.,projection='lcc',\
lat_1=50.,lon_0=-107.)
# define grid (nx x ny regularly spaced native projection grid)
nx = int((m.xmax - m.xmin) / 40000.) + 1
ny = int((m.ymax - m.ymin) / 40000.) + 1
lonsout, latsout = m.makegrid(nx, ny)
topodat = interp(topoin, lons, lats, lonsout, latsout)
xsize = rcParams['figure.figsize'][0]
fig = figure(figsize=(xsize, m.aspect * xsize))
ax = fig.add_axes([0.1, 0.1, 0.75, 0.75])
im = imshow(topodat,
cm.jet,
extent=(m.xmin, m.xmax, m.ymin, m.ymax),
origin='lower')
cax = axes([0.875, 0.1, 0.05, 0.75])
def plot_track(rlon, rlat=None, m=None, **keywords):
show_lat = 1
if ('show_lat' in keywords):
show_lat = keywords['show_lat']
show_lon = 1
if ('show_lon' in keywords):
show_lon = keywords['show_lon']
if (m == None):
map_proj = 'cyl'
if ('map_proj' in keywords):
map_proj = keywords['map_proj']
lat_0 = 0.0
if ('lat_0' in keywords):
lat_0 = keywords['lat_0']
minlat = -90.0
maxlat = 90.0
if ('minlat' in keywords):
minlat = keywords['minlat']
if ('maxlat' in keywords):
maxlat = keywords['maxlat']
minlon = -180
maxlon = 180.0
if ('minlon' in keywords):
minlon = keywords['minlon']
if ('maxlon' in keywords):
maxlon = keywords['maxlon']
lon_0 = 0
if ('lon_0' in keywords):
lon_0 = keywords['lon_0']
boundinglat = 45
if ('boundinglat' in keywords):
boundinglat = keywords['boundinglat']
if (map_proj == 'npstere' or map_proj == 'spstere'):
m = Basemap(projection=map_proj,
lon_0=lon_0,
boundinglat=boundinglat)
elif (map_proj == 'ortho'):
m = Basemap(projection=map_proj, lon_0=lon_0, lat_0=lat_0)
else:
m=Basemap(llcrnrlon=minlon, llcrnrlat=minlat, \
urcrnrlon=maxlon, urcrnrlat=maxlat,projection=map_proj, lon_0=lon_0, lat_0=lat_0)
if (show_lat == 1):
m.drawparallels(arange(minlat, maxlat + 30.0, 30.),
labels=[1, 0, 0, 0])
if (show_lon == 1):
m.drawmeridians(arange(minlon, maxlon + 60, 60.),
labels=[0, 0, 0, 1])
sgn = '+'
if ('sgn' in keywords):
sgn = keywords['sgn']
if ('color' in keywords):
lcolor = keywords['color']
if (len(rlon) < 100):
m.plot(rlon, rlat, sgn, color=lcolor, markersize=11)
else:
m.plot(rlon, rlat, sgn, color=lcolor, markersize=6)
else:
m.plot(rlon, rlat, sgn)
m.drawcoastlines(color='w', linewidth=0.5)
m.drawmapboundary()
# m.drawcountries(color='k', linewidth=0.5)
if ('title' in keywords):
stitle = keywords['title']
title(stitle)
return m
data.y, 2, oban.barnes_weights, (kappa0, g))
barnes_analyses.append(field)
diffs = oban.get_ob_incs(data.x, data.y, data.heights, x, y, field)
barnes_rms.append(misc.rms(diffs))
print "Barnes 2-pass gamma=%.1f rms: %f" % (g, barnes_rms[-1])
#Do the barnes 3-pass
barnes_3pass = oban.analyze_grid_multipass(data.heights, x_grid, y_grid,
data.x, data.y, 3, oban.barnes_weights, (kappa0, 1.0))
diffs = oban.get_ob_incs(data.x, data.y, data.heights, x, y, barnes_3pass)
barnes_3pass_rms = misc.rms(diffs)
print "Barnes 3-pass rms: %f" % barnes_3pass_rms
#Generate a grid for basemap plotting
bm_ps = Basemap(projection='stere',lat_0=90.0,lon_0=-110.0,lat_ts=60.0,
rsphere=ps.radius,llcrnrlon=-120.5,llcrnrlat=25.1,urcrnrlon=-61.8,
urcrnrlat=43.4,resolution='l',area_thresh=5000)
#Transform the grid to basemap space for plotting
x_bm,y_bm = ps.to_basemap_xy(bm_ps, x_grid / cm_per_m, y_grid / cm_per_m)
#Check if we want to view or save output
if len(sys.argv) > 1 and sys.argv[1].startswith('silent'):
save_work = True
colormap = M.cm.get_cmap('gist_gray')
fontsize = 10
else:
save_work = False
colormap = M.cm.get_cmap('jet')
fontsize = 14
# example demonstrating how to draw a great circle on a map.
import matplotlib
from matplotlib.toolkits.basemap import Basemap
from pylab import *
# setup a mercator projection.
m = Basemap(-90.,30.,30.,60.,\
resolution='c',area_thresh=10000.,projection='merc',\
lat_ts=20.)
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
fig.add_axes([0.1,0.1,0.8,0.8])
ax = gca() # get current axis instance
ax.update_datalim(((m.llcrnrx, m.llcrnry),(m.urcrnrx,m.urcrnry)))
ax.set_xlim((m.llcrnrx, m.urcrnrx))
ax.set_ylim((m.llcrnry, m.urcrnry))
m.drawcoastlines(ax)
m.fillcontinents(ax)
# draw parallels
circles = [35,45,55]
m.drawparallels(ax,circles,labels=[1,1,0,1])
# draw meridians
meridians = [-90,-60,-30,0,30]
m.drawmeridians(ax,meridians,labels=[1,1,0,1])
# nylat, nylon are lat/lon of New York
nylat = 40.78
nylon = -73.98
# lonlat, lonlon are lat/lon of London.
lonlat = 51.53
lonlon = 0.08
# draw the great circle.
from matplotlib.toolkits.basemap import Basemap, shiftgrid
from pylab import *
# read in topo data (on a regular lat/lon grid)
# longitudes go from 20 to 380.
topoin = array(load('etopo20data.gz'),'d')
lons = array(load('etopo20lons.gz'),'d')
lats = array(load('etopo20lats.gz'),'d')
# shift data so lons go from -180 to 180 instead of 20 to 380.
topoin,lons = shiftgrid(180.,topoin,lons,start=False)
# setup of basemap ('lcc' = lambert conformal conic).
# use major and minor sphere radii from WGS84 ellipsoid.
m = Basemap(llcrnrlon=-145.5,llcrnrlat=1.,urcrnrlon=-2.566,urcrnrlat=46.352,\
rsphere=(6378137.00,6356752.3142),\
resolution='l',area_thresh=1000.,projection='lcc',\
lat_1=50.,lon_0=-107.)
# transform to nx x ny regularly spaced native projection grid
nx = int((m.xmax-m.xmin)/40000.)+1; ny = int((m.ymax-m.ymin)/40000.)+1
topodat,x,y = m.transform_scalar(topoin,lons,lats,nx,ny,returnxy=True)
# create the figure.
fig=figure(figsize=(8,8))
# add an axes, leaving room for colorbar on the right.
ax = fig.add_axes([0.1,0.1,0.7,0.7])
# plot image over map with imshow.
im = m.imshow(topodat,cm.jet)
# setup colorbar axes instance.
l,b,w,h = ax.get_position()
cax = axes([l+w+0.075, b, 0.05, h])
colorbar(tickfmt='%d', cax=cax) # draw colorbar
axes(ax) # make the original axes current again
lats = 90. - delat * arange(nlats)
lons, lats = meshgrid(lons, lats)
lons = (d2r * lons.flat).tolist()
lats = (d2r * lats.flat).tolist()
# randomly shuffle locations.
random.shuffle(lons)
random.shuffle(lats)
lons = array(lons, 'f')
lats = array(lats, 'f')
# minimum separation distance in km.
rcrit = 500.
# set up lambert azimuthal map centered on N. Pole.
m = Basemap(llcrnrlon=-150.,llcrnrlat=0.,urcrnrlon=30.,urcrnrlat=0.,
resolution='l',area_thresh=10000.,projection='stere',\
lat_0=90.,lon_0=-105.,lat_ts=90.)
print len(lons), ' obs before thinning'
# calculate distance between each ob and all preceding obs in list.
# throw out those that are closer than rcrit.
nob = 0
lats_out = []
lons_out = []
for lon, lat in zip(lons, lats):
if nob:
r = (m.rmajor / 1000.) * get_dist(lon, lons[0:nob], lat, lats[0:nob])
if min(r) > rcrit:
lats_out.append(lat)
lons_out.append(lon)
from matplotlib.toolkits.basemap import Basemap
from pylab import *
import cPickle
# create Basemap instance. Use 'crude' resolution coastlines.
m = Basemap(llcrnrlon=-11.,llcrnrlat=50.5,urcrnrlon=-5.,urcrnrlat=56.,
resolution='c',area_thresh=1000.,projection='tmerc',lon_0=-8.,lat_0=0.)
# create figure with same aspect ratio as map.
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
fig.add_axes([0.1,0.1,0.8,0.8])
# draw coastlines and fill continents.
m.drawcoastlines()
m.fillcontinents()
# draw political boundaries.
m.drawcountries()
# draw parallels
circles = arange(50,60,1).tolist()
m.drawparallels(circles,labels=[1,1,0,0])
# draw meridians
meridians = arange(-12,0,1)
m.drawmeridians(meridians,labels=[0,0,1,1])
title("Crude Res Boundaries ('c')",y=1.075)
show()
# create Basemap instance. Use 'low' resolution coastlines.
m = Basemap(llcrnrlon=-11.,llcrnrlat=50.5,urcrnrlon=-5.,urcrnrlat=56.,
resolution='l',area_thresh=1000.,projection='tmerc',lon_0=-8.,lat_0=0.)
# create figure with same aspect ratio as map.
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
hgt = P.load("500hgtdata.gz")
lons = P.load("500hgtlons.gz")
lats = P.load("500hgtlats.gz")
lons, lats = P.meshgrid(lons, lats)
# Example to show how to make multi-panel plots.
# 2-panel plot, oriented vertically, colorbar on bottom.
rcParams["figure.subplot.hspace"] = 0.4 # more height between subplots
rcParams["figure.subplot.wspace"] = 0.5 # more width between subplots
# create new figure
fig = P.figure()
# panel 1
mnh = Basemap(lon_0=-105, boundinglat=20.0, resolution="c", area_thresh=10000.0, projection="nplaea")
xnh, ynh = mnh(lons, lats)
ax = fig.add_subplot(211)
CS = mnh.contour(xnh, ynh, hgt, 15, linewidths=0.5, colors="k")
CS = mnh.contourf(xnh, ynh, hgt, 15, cmap=P.cm.Spectral)
# colorbar on bottom.
l, b, w, h = ax.get_position()
cax = P.axes([l, b - 0.05, w, 0.025]) # setup colorbar axes
P.colorbar(cax=cax, orientation="horizontal", ticks=CS.levels[0::4]) # draw colorbar
P.axes(ax) # make the original axes current again
mnh.drawcoastlines(linewidth=0.5)
delat = 30.0
circles = P.arange(0.0, 90.0, delat).tolist() + P.arange(-delat, -90, -delat).tolist()
mnh.drawparallels(circles, labels=[1, 0, 0, 0])
delon = 45.0
meridians = P.arange(0, 360, delon)
# example demonstrating how to draw a great circle on a map.
import matplotlib
from matplotlib.toolkits.basemap import Basemap
from pylab import *
# setup a mercator projection.
m = Basemap(-90.,30.,30.,60.,\
resolution='c',area_thresh=10000.,projection='merc',\
lat_ts=20.)
xsize = rcParams['figure.figsize'][0]
fig = figure(figsize=(xsize, m.aspect * xsize))
fig.add_axes([0.1, 0.1, 0.8, 0.8])
ax = gca() # get current axis instance
ax.update_datalim(((m.llcrnrx, m.llcrnry), (m.urcrnrx, m.urcrnry)))
ax.set_xlim((m.llcrnrx, m.urcrnrx))
ax.set_ylim((m.llcrnry, m.urcrnry))
m.drawcoastlines(ax)
m.fillcontinents(ax)
# draw parallels
circles = [35, 45, 55]
m.drawparallels(ax, circles, labels=[1, 1, 0, 1])
# draw meridians
meridians = [-90, -60, -30, 0, 30]
m.drawmeridians(ax, meridians, labels=[1, 1, 0, 1])
# nylat, nylon are lat/lon of New York
nylat = 40.78
nylon = -73.98
# lonlat, lonlon are lat/lon of London.
lonlat = 51.53
lonlon = 0.08
# draw the great circle.
def plot_track(rlon, rlat=None, m=None, **keywords):
show_lat = 1
if ('show_lat' in keywords):
show_lat = keywords['show_lat']
show_lon = 1
if ('show_lon' in keywords):
show_lon = keywords['show_lon']
if (m is None):
map_proj = 'cyl'
if ('map_proj' in keywords):
map_proj = keywords['map_proj']
lat_0 = 0.0
if ('lat_0' in keywords):
lat_0 = keywords['lat_0']
minlat = -90.0
maxlat = 90.0
if ('minlat' in keywords):
minlat = keywords['minlat']
if ('maxlat' in keywords):
maxlat = keywords['maxlat']
minlon = -180
maxlon = 180.0
if ('minlon' in keywords):
minlon = keywords['minlon']
if ('maxlon' in keywords):
maxlon = keywords['maxlon']
lon_0 = 0
if ('lon_0' in keywords):
lon_0 = keywords['lon_0']
boundinglat = 45
if ('boundinglat' in keywords):
boundinglat = keywords['boundinglat']
if (map_proj == 'npstere' or map_proj == 'spstere'):
m = Basemap(projection=map_proj,
lon_0=lon_0,
boundinglat=boundinglat)
elif (map_proj == 'ortho'):
m = Basemap(projection=map_proj, lon_0=lon_0, lat_0=lat_0)
else:
m = Basemap(llcrnrlon=minlon,
llcrnrlat=minlat,
urcrnrlon=maxlon,
urcrnrlat=maxlat,
projection=map_proj,
lon_0=lon_0,
lat_0=lat_0)
if (show_lat == 1):
m.drawparallels(arange(minlat, maxlat + 30.0, 30.),
labels=[1, 0, 0, 0])
if (show_lon == 1):
m.drawmeridians(arange(minlon, maxlon + 60, 60.),
labels=[0, 0, 0, 1])
sgn = 'o'
if ('sgn' in keywords):
sgn = keywords['sgn']
if ('color' in keywords):
print('I am here', size(rlon))
lcolor = keywords['color']
print(max(lcolor), min(lcolor))
if ('minv' in keywords):
vmin = keywords['minv']
else:
vmin = min(lcolor)
if ('maxv' in keywords):
vmax = keywords['maxv']
else:
vmax = max(lcolor)
cx = cm.jet
cx.set_over('r')
cx.set_under('w')
x, y = m(rlon, rlat)
if (len(rlon) < 100):
scatter(x,
y,
marker=sgn,
c=lcolor,
s=30.0,
color='w',
vmin=vmin,
vmax=vmax,
cmap=cx) # , markersize=11)
else:
scatter(x,
y,
marker=sgn,
c=lcolor,
s=26,
edgecolor='w',
vmin=vmin,
vmax=vmax,
cmap=cx) # , markersize=6)
cbar_vert = 1
if ('cbar_vert' in keywords):
cbar_vert = keywords['cbar_vert']
if (cbar_vert == 1):
orientation = 'vertical'
else:
orientation = 'horizontal'
show_colorbar = 0
if ('cb' in keywords):
show_colorbar = keywords['cb']
if (show_colorbar == 1):
colorbar(orientation=orientation)
# colorbar(cmap=cx)
m.drawcoastlines(color='k', linewidth=1.0)
m.drawmapboundary()
# m.drawcountries(color='k', linewidth=0.5)
if ('title' in keywords):
stitle = keywords['title']
title(stitle)
return m
bounding_lat = 20.
# loop over projections, one for each panel of the figure.
fig = figure(figsize=(8, 8))
npanel = 0
for proj, projname in zip(projs, projnames):
npanel = npanel + 1
if hem == 'South':
projection = 'sp' + proj
elif hem == 'North':
projection = 'np' + proj
# setup map projection
# centered on Australia (for SH) or US (for NH).
if proj == 'ortho':
m = Basemap(projection='ortho',
resolution='c',
area_thresh=10000.,
lat_0=lat_0,
lon_0=lon_0_ortho)
else:
m = Basemap(boundinglat=bounding_lat,lon_0=lon_0,\
resolution='c',area_thresh=10000.,projection=projection)
# compute native map projection coordinates for lat/lon grid.
x, y = m(*meshgrid(lons, lats))
ax = fig.add_subplot(2, 2, npanel)
# make filled contour plot.
cs = m.contourf(x, y, etopo, 20, cmap=cm.jet)
# draw coastlines.
m.drawcoastlines()
# draw parallels and meridians.
m.drawparallels(arange(-80., 90, 20.))
m.drawmeridians(arange(0., 360., 60.))
from gdalconst import *
import pylab as p
# download from
# http://edcftp.cr.usgs.gov/pub/data/DEM/250/D/denver-w.gz
gd = gdal.Open('denver-w')
# get data from DEM file
array = gd.ReadAsArray()
# get lat/lon coordinates from DEM file.
coords = gd.GetGeoTransform()
llcrnrlon = coords[0]
urcrnrlon = llcrnrlon+(array.shape[1]-1)*coords[1]
urcrnrlat = coords[3]
llcrnrlat = urcrnrlat+(array.shape[0]-1)*coords[5]
# create Basemap instance.
m = Basemap(llcrnrlon=llcrnrlon,llcrnrlat=llcrnrlat,urcrnrlon=urcrnrlon,urcrnrlat=urcrnrlat,projection='cyl')
# create a figure, add an axes
# (leaving room for a colorbar).
fig = p.figure()
ax = fig.add_axes([0.1,0.1,0.75,0.75])
# plot image from DEM over map.
im = m.imshow(array,origin='upper')
# make a colorbar.
cax = p.axes([0.875, 0.1, 0.05, 0.75]) # setup colorbar axes.
p.colorbar(cax=cax) # draw colorbar
p.axes(ax) # make the original axes current again
# draw meridians and parallels.
m.drawmeridians(p.linspace(llcrnrlon+0.1,urcrnrlon-0.1,5),labels=[0,0,0,1],fmt='%4.2f')
m.drawparallels(p.linspace(llcrnrlat+0.1,urcrnrlat-0.1,5),labels=[1,0,0,0],fmt='%4.2f')
# plot county boundaries from
# http://edcftp.cr.usgs.gov/pub/data/nationalatlas/countyp020.tar.gz
from matplotlib.toolkits.basemap import Basemap
from pylab import *
# create Basemap instance. Use 'crude' resolution coastlines.
m = Basemap(-11.,
51.,
-5.,
56.,
resolution='c',
area_thresh=1000.,
projection='cyl')
# create figure with same aspect ratio as map.
xsize = rcParams['figure.figsize'][0]
fig = figure(figsize=(xsize, m.aspect * xsize))
fig.add_axes([0.1, 0.1, 0.8, 0.8])
# draw coastlines and fill continents.
m.drawcoastlines()
m.fillcontinents()
# draw parallels
circles = arange(50, 60, 1).tolist()
m.drawparallels(circles, labels=[1, 1, 1, 1])
# draw meridians
meridians = arange(-12, 0, 1)
m.drawmeridians(meridians, labels=[1, 1, 1, 1])
title("Crude Res Coastlines ('c')", y=1.075)
show()
# create Basemap instance. Use 'low' resolution coastlines.
m = Basemap(-11.,
51.,
-5.,
"""
def __init__(self, baseMap):
"""baseMap is the Basemap object that will be used to translate between
lon/lat and native map coordinates.
"""
self.baseMap = baseMap
def __call__(self, y, pos=1):
"""Return the label for tick value y at position pos.
"""
lon, lat = self.baseMap(0.0, y, inverse=True)
return "%g" % lat
m = Basemap(-180.,-80.,180.,80.,\
resolution='c',area_thresh=10000.,projection='merc',\
lat_ts=20.)
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
fig.add_axes([0.1,0.1,0.8,0.8])
ax = gca() # get current axis instance
ax.update_datalim(((m.llcrnrx, m.llcrnry),(m.urcrnrx,m.urcrnry)))
ax.set_xlim((m.llcrnrx, m.urcrnrx))
ax.set_ylim((m.llcrnry, m.urcrnry))
m.drawcoastlines(ax)
m.drawcountries(ax)
m.drawstates(ax)
m.fillcontinents(ax)
# draw parallels
delat = 30.
circles = arange(0.,90.,delat).tolist()+\
#lonfile = '/home/blew/programy/Mscs/WMAPstuff/SKregstat/sm1.0/3sigma_chisq_comb-K.lon'
#latfile = '/home/blew/programy/Mscs/WMAPstuff/SKregstat/sm1.0/3sigma_chisq_comb-K.lat'
mapfile = sys.argv[1]+'.lonlatT'
lonfile = sys.argv[1]+'.lon'
latfile = sys.argv[1]+'.lat'
color_num = int(sys.argv[2])
# load data
map=array(load(mapfile))
lons=array(load(lonfile))
lats=array(load(latfile))
map,lons = shiftgrid(180.,map,lons,start=False)
# Mollweide projection
m1 = Basemap(projection='moll',lon_0=0.5*(lons[0]+lons[-1]))
lons, lats = meshgrid(lons, lats)
fig1 = m1.createfigure()
x, y = m1(lons, lats)
cs = m1.contourf(x,y,map,color_num,cmap=cm.jet)
m1.drawparallels(arange(-90.,90.,20.),labels=[1,0,0,0])
m1.drawmeridians(arange(0.,420.,30.),labels=[0,0,0,1])
#title('Moll. proj:'+ sys.argv[1])
title(r'$>3\sigma\/ detections\/ composite\/ map:\/ skewness$')
#title(r'$>3\sigma\/ detections\/ composite\/ map:\/ kurtosis$')
colorbar();
savefig(sys.argv[1]+'-moll.png'); #savefig(sys.argv[1]+'-moll.eps')
savefig(sys.argv[1]+'-moll.jpg');
pylab.clf()
b = 5.
# Plot the region surrounding the coastline rounded to the nearest 5 degree lat/lon.
lonmin = b*math.floor(min(lon)/b)
lonmax = b*math.ceil(max(lon)/b)
latmin = b*math.floor(min(lat)/b)
latmax = b*math.ceil(max(lat)/b)
meridian = (range(lonmin, lonmax+b, b))
parallel = (range(latmin, latmax+b, b))
prj = 'cyl'
res = 'i'
map = Basemap(projection=prj,
llcrnrlon=lonmin,
llcrnrlat=latmin,
urcrnrlon=lonmax,
urcrnrlat=latmax,
resolution=res)
map.plot(lon, lat, 'r-')
map.plot(lon, lat, 'k+')
fs = 10
pylab.text(115.9,-31.9, "Perth", fontsize=fs, ha='left', va='top')
pylab.text(114.1,-21.9, "Exmouth", fontsize=fs, ha='left', va='top')
pylab.text(118.5,-20.4, "Port Hedland", fontsize=fs, ha='left', va='top')
pylab.text(130.8,-12.6, "Darwin", fontsize=fs, ha='left', va='top')
pylab.text(145.75,-16.9, "Cairns", fontsize=fs, ha='right', va='top')
pylab.text(149.2,-21.2, "Mackay", fontsize=fs, ha='right', va='top')
pylab.text(153.0,-27.5, "Brisbane", fontsize=fs, ha='right', va='top')
lat_0 = 40.
lon_0 = -100.
width = 6000000.
height = 2. * width / 3.
delat = 25.
circles = arange(0.,90.+delat,delat).tolist()+\
arange(-delat,-90.-delat,-delat).tolist()
delon = 30.
meridians = arange(10., 360., delon)
npanel = 0
# plots of the US.
projs = ['lcc', 'aeqd', 'aea', 'laea', 'eqdc', 'stere']
fig = figure(figsize=(8, 12))
for proj in projs:
m = Basemap(width=width,height=height,
resolution='c',projection=proj,\
lat_0=lat_0,lon_0=lon_0)
npanel = npanel + 1
fig.add_subplot(3, 2, npanel)
# setup figure with same aspect ratio as map.
m.drawcoastlines()
m.drawcountries()
m.fillcontinents()
m.drawstates()
m.drawparallels(circles)
m.drawmeridians(meridians)
title('proj = ' + proj + ' centered on %sW, %sN' % (lon_0, lat_0),
fontsize=10)
proj = 'omerc'
delat = 10.
figure, title, meshgrid, cm, arange
# examples of filled contour plots on map projections.
# read in data on lat/lon grid.
hgt = load('500hgtdata.gz')
lons = load('500hgtlons.gz')
lats = load('500hgtlats.gz')
# shift data so lons go from -180 to 180 instead of 0 to 360.
hgt,lons = shiftgrid(180.,hgt,lons,start=False)
lons, lats = meshgrid(lons, lats)
# create new figure
fig=figure()
# setup of sinusoidal basemap
m = Basemap(resolution='c',projection='sinu',lon_0=0)
ax = fig.add_axes([0.1,0.1,0.7,0.7])
# make a filled contour plot.
x, y = m(lons, lats)
CS = m.contour(x,y,hgt,15,linewidths=0.5,colors='k')
CS = m.contourf(x,y,hgt,15,cmap=cm.jet)
l,b,w,h=ax.get_position()
cax = axes([l+w+0.075, b, 0.05, h]) # setup colorbar axes
colorbar(drawedges=True, cax=cax) # draw colorbar
axes(ax) # make the original axes current again
# draw coastlines and political boundaries.
m.drawcoastlines()
m.drawmapboundary()
m.fillcontinents()
# draw parallels and meridians.
parallels = arange(-60.,90,30.)
from matplotlib.toolkits.basemap import Basemap
import pylab as p
# set up orthographic map projection with
# perspective of satellite looking down at 50N, 100W.
# use low resolution coastlines.
map = Basemap(projection='ortho',lat_0=50,lon_0=-100,resolution='l')
# draw coastlines, country boundaries, fill continents.
map.drawcoastlines(linewidth=0.25)
map.drawcountries(linewidth=0.25)
map.fillcontinents(color='coral')
# draw the edge of the map projection region (the projection limb)
map.drawmapboundary()
# draw lat/lon grid lines every 30 degrees.
map.drawmeridians(p.arange(0,360,30))
map.drawparallels(p.arange(-90,90,30))
# lat/lon coordinates of five cities.
lats=[40.02,32.73,38.55,48.25,17.29]
lons=[-105.16,-117.16,-77.00,-114.21,-88.10]
cities=['Boulder, CO','San Diego, CA',
'Washington, DC','Whitefish, MT','Belize City, Belize']
# compute the native map projection coordinates for cities.
x,y = map(lons,lats)
# plot filled circles at the locations of the cities.
map.plot(x,y,'bo')
# plot the names of those five cities.
for name,xpt,ypt in zip(cities,x,y):
p.text(xpt+50000,ypt+50000,name,fontsize=9)
# make up some data on a regular lat/lon grid.
nlats = 73; nlons = 145; delta = 2.*p.pi/(nlons-1)
lats = (0.5*p.pi-delta*p.indices((nlats,nlons))[0,:,:])
lons = (delta*p.indices((nlats,nlons))[1,:,:])
from pylab import *
import cPickle
# read in topo data from pickle (on a regular lat/lon grid)
# longitudes go from 20 to 380.
topodict = cPickle.load(open('etopo20.pickle','rb'))
topoin = topodict['data']; lons = topodict['lons']; lats = topodict['lats']
# shift data so lons go from -180 to 180 instead of 20 to 380.
topoin,lons = shiftgrid(180.,topoin,lons,start=False)
print 'min/max etopo20 data:'
print min(ravel(topoin)),max(ravel(topoin))
# setup cylindrical equidistant map projection (global domain).
m = Basemap(-180.,-90,180.,90.,\
resolution='c',area_thresh=10000.,projection='cyl')
# setup figure with same aspect ratio as map.
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
ax = fig.add_axes([0.1,0.1,0.75,0.75])
# plot image over map.
im = m.imshow(topoin,cm.jet)
cax = axes([0.875, 0.1, 0.05, 0.75]) # setup colorbar axes.
colorbar(tickfmt='%d', cax=cax) # draw colorbar
axes(ax) # make the original axes current again
m.drawcoastlines()
#m.drawcountries()
#m.drawstates()
#m.fillcontinents()
# draw parallels
delat = 30.
def draw_graph_on_map(g, node2weight, node2pos, pic_title, pic_area=[-130,10,140,70], output_fname_prefix=None, need_draw_edge=0):
"""
2007-09-13
identity_pair_ls is a list of pairs of strains (ecotype id as in table ecotype)
2007-10-08
correct a bug in 4*diameter_ls, diameter_ls has to be converted to array first.
sqrt the node weight, 8 times the original weight
"""
import os, sys
sys.stderr.write("Drawing graph on a map ...\n")
import pylab, math
from matplotlib.toolkits.basemap import Basemap
pylab.clf()
fig = pylab.figure()
fig.add_axes([0.05,0.05,0.9,0.9]) #[left, bottom, width, height]
m = Basemap(llcrnrlon=pic_area[0],llcrnrlat=pic_area[1],urcrnrlon=pic_area[2],urcrnrlat=pic_area[3],\
resolution='l',projection='mill', ax=pylab.gca())
sys.stderr.write("\tDrawing nodes ...")
euc_coord1_ls = []
euc_coord2_ls = []
diameter_ls = []
for n in g.nodes():
lat, lon = node2pos[n]
euc_coord1, euc_coord2 = m(lon, lat) #longitude first, latitude 2nd
euc_coord1_ls.append(euc_coord1)
euc_coord2_ls.append(euc_coord2)
diameter_ls.append(math.sqrt(node2weight[n]))
import numpy
diameter_ls = numpy.array(diameter_ls)
m.scatter(euc_coord1_ls, euc_coord2_ls, 8*diameter_ls, marker='o', color='r', alpha=0.4, zorder=12, faceted=False)
sys.stderr.write("Done.\n")
if need_draw_edge:
sys.stderr.write("\tDrawing edges ...")
ax=pylab.gca()
for popid1, popid2, no_of_connections in g.edges():
lat1, lon1 = node2pos[popid1]
lat2, lon2 = node2pos[popid2]
x1, y1 = m(lon1, lat1)
x2, y2 = m(lon2, lat2)
ax.plot([x1,x2],[y1,y2], 'g', linewidth=math.log(no_of_connections+1)/2, alpha=0.2, zorder=10)
sys.stderr.write("Done.\n")
#m.drawcoastlines()
m.drawparallels(pylab.arange(-90,90,30), labels=[1,1,0,1])
m.drawmeridians(pylab.arange(-180,180,30), labels=[1,1,0,1])
m.fillcontinents()
m.drawcountries()
m.drawstates()
pylab.title(pic_title)
if output_fname_prefix:
pylab.savefig('%s.eps'%output_fname_prefix, dpi=600)
pylab.savefig('%s.svg'%output_fname_prefix, dpi=600)
pylab.savefig('%s.png'%output_fname_prefix, dpi=600)
del fig, m, pylab
sys.stderr.write("Done.\n")
lats = 90.-delat*arange(nlats)
lons, lats = meshgrid(lons, lats)
lons = (d2r*lons.flat).tolist()
lats = (d2r*lats.flat).tolist()
# randomly shuffle locations.
random.shuffle(lons)
random.shuffle(lats)
lons = array(lons,'f')
lats = array(lats,'f')
# minimum separation distance in km.
rcrit = 500.
# set up lambert azimuthal map centered on N. Pole.
m = Basemap(llcrnrlon=-150.,llcrnrlat=0.,urcrnrlon=30.,urcrnrlat=0.,
resolution='l',area_thresh=10000.,projection='stere',\
lat_0=90.,lon_0=-105.,lat_ts=90.)
print len(lons), ' obs before thinning'
# calculate distance between each ob and all preceding obs in list.
# throw out those that are closer than rcrit.
nob = 0
lats_out = []
lons_out = []
for lon,lat in zip(lons,lats):
if nob:
r = (m.rmajor/1000.)*get_dist(lon,lons[0:nob],lat,lats[0:nob])
if min(r) > rcrit:
lats_out.append(lat)
lons_out.append(lon)
# in which direction to depart for other points on earth and how far
# it will be to reach that destination.
# The specified point shows up as a red dot in the center of the map.
# This example shows how to use the width and height keywords
# to specify the map projection region (instead of specifying
# the lat/lon of the upper right and lower left corners).
# user enters the lon/lat of the point, and it's name
lon_0 = float(raw_input('input reference lon (degrees):'))
lat_0 = float(raw_input('input reference lat (degrees):'))
location = raw_input('name of location:')
# use these values to setup Basemap instance.
width = 28000000
m = Basemap(width=width,height=width,\
resolution='c',projection='aeqd',\
lat_0=lat_0,lon_0=lon_0)
# draw coasts and fill continents.
m.drawcoastlines(linewidth=0.5)
m.fillcontinents()
# 20 degree graticule.
m.drawparallels(arange(-80,81,20))
m.drawmeridians(arange(-180,180,20))
# draw a red dot at the center.
xpt, ypt = m(lon_0, lat_0)
m.plot([xpt],[ypt],'ro')
# draw the title.
title('The World According to Garp in '+location)
show()
def plot_map(data, rlon=None, rlat=None, use_pcolor=0, **keywords):
""" display the data in a map
keywords: dict which can include the following keywords minv=0.0, maxv=0.0, dv=0.0,
show_map=0, map_proj='cyl', show_lat=0, show_lon=0, lat_0=0.0, lon_0=0.0,
minlat=-90.0, maxlat=90.0, minlon=0.0, maxlon=360.0, use_log=0, level=level
"""
minv = 0.0
if ('minv' in keywords):
minv = keywords['minv']
maxv = 0.0
if ('maxv' in keywords):
maxv = keywords['maxv']
dv = 0.0
if ('dv' in keywords):
dv = keywords['dv']
if ('dv' in keywords):
dv = keywords['dv']
if (maxv > minv):
rlvl = arange(minv, maxv + dv, dv)
rlvl[0] = -999.0
rlvl[size(rlvl) - 1] = 999.
stitle = ""
add_str = ""
if ('title' in keywords):
add_str = keywords['title']
add_str = add_str.strip()
stitle = stitle + ' ' + add_str
if ('unit' in keywords):
add_str = keywords['unit']
add_str = add_str.strip()
stitle = stitle + '(' + add_str + ')'
cbar_vert = 1
if ('cbar_vert' in keywords):
cbar_vert = keywords['cbar_vert']
if (cbar_vert == 1):
orientation = 'vertical'
else:
orientation = 'horizontal'
show_lat = 1
if ('show_lat' in keywords):
show_lat = keywords['show_lat']
show_lon = 1
if ('show_lon' in keywords):
show_lon = keywords['show_lon']
nlon, nlat = shape(data)
vals = array(data)
map_proj = 'cyl'
if ('map_proj' in keywords):
map_proj = keywords['map_proj']
lat_0 = 0.0
if ('lat_0' in keywords):
lat_0 = keywords['lat_0']
minlat = -90.0
maxlat = 90.0
if ('minlat' in keywords):
minlat = keywords['minlat']
if ('maxlat' in keywords):
maxlat = keywords['maxlat']
if (rlat == None):
dlat = (maxlat - minlat) / nlat
rlat = arange(minlat, maxlat, dlat)
minlon = -180
maxlon = 180.0
if ('minlon' in keywords):
minlon = keywords['minlon']
if ('maxlon' in keywords):
maxlon = keywords['maxlon']
if (rlon == None):
dlon = (maxlon - minlon) / nlon
rlon = arange(minlon, maxlon, dlon)
lon_0 = 0
do_bdr = 0
if ('do_bdr' in keywords):
do_bdr = keywords['do_bdr']
if ('lon_0' in keywords):
lon_0 = keywords['lon_0']
boundinglat = 45
if ('boundinglat' in keywords):
boundinglat = keywords['boundinglat']
if (map_proj == 'npstere' or map_proj == 'spstere'):
m = Basemap(projection=map_proj, lon_0=lon_0, boundinglat=boundinglat)
elif (map_proj == 'ortho'):
m = Basemap(projection=map_proj, lon_0=lon_0, lat_0=lat_0)
else:
if (maxlon - minlon > 180):
m=Basemap(llcrnrlon=minlon, llcrnrlat=minlat, \
urcrnrlon=maxlon, urcrnrlat=maxlat,projection=map_proj, lon_0=lon_0, lat_0=lat_0, resolution='l')
else:
m=Basemap(llcrnrlon=minlon, llcrnrlat=minlat, \
urcrnrlon=maxlon, urcrnrlat=maxlat,projection=map_proj, lon_0=lon_0, lat_0=lat_0, resolution='i')
if (rlon[-1] < rlon[0] + 360.0):
rlon = resize(rlon, nlon + 1)
rlon[-1] = rlon[0] + 360.0
vals = squeeze(vals)
vals = resize(vals, [nlon + 1, nlat])
x, y = m(*meshgrid(rlon, rlat))
cmap = cm.Paired
if ('cmap' in keywords):
print 'cmap included'
cmap = keywords['cmap']
m.drawcoastlines(color='k', linewidth=0.5)
if (maxv > minv):
if (use_pcolor == 1):
cs0 = m.pcolormesh(x,
y,
transpose(vals),
shading='flat',
vmin=minv,
vmax=maxv,
cmap=cmap)
# cs0=m.imshow(x, y, transpose(vals), shading='flat', vmin=minv, vmax=maxv, cmap=cmap)
else:
cs0 = m.contourf(x, y, transpose(vals), rlvl, cmap=cmap)
else:
if (use_pcolor == 1):
cs0 = m.pcolor(x, y, transpose(vals), shading='flat', cmap=cmap)
else:
cs0 = m.contourf(x, y, transpose(vals), cmap=cmap)
# info(m.drawcoastlines)
# m.drawcountries(color=white)
m.drawmapboundary()
if (show_lat == 1):
if (maxlat - minlat >= 90):
m.drawparallels(arange(minlat, maxlat + 30.0, 30.),
labels=[1, 0, 0, 0],
color='grey')
else:
m.drawparallels(arange(minlat, maxlat + 5.0, 5.),
labels=[1, 0, 0, 0],
color='grey')
if (show_lon == 1):
if (maxlon - minlon >= 180):
m.drawmeridians(arange(minlon, maxlon + 60, 60.),
labels=[0, 0, 0, 1],
color='grey')
else:
m.drawmeridians(arange(minlon, maxlon + 10, 10.),
labels=[0, 0, 0, 1],
color='grey')
title(stitle)
show_colorbar = 1
if ('cb' in keywords):
show_colorbar = keywords['cb']
if (show_colorbar == 1):
colorbar(orientation=orientation, extend='both')
if (do_bdr == 1):
lvl = arange(max(vals.flat))
print shape(x), shape(y), shape(vals)
# cs2=m.contour(x[0:-1,:], y[0:-1,:], transpose(vals), lvl, colors='k', linewidth=0.5)
return m
# country boundaries, and parallels/meridians.
from matplotlib.toolkits.basemap import Basemap, shiftgrid
from pylab import *
import cPickle
# read in topo data from pickle (on a regular lat/lon grid)
# longitudes go from 20 to 380.
topodict = cPickle.load(open('etopo20.pickle','rb'))
topoin = topodict['data']; lons = topodict['lons']; lats = topodict['lats']
# shift data so lons go from -180 to 180 instead of 20 to 380.
topoin,lons = shiftgrid(180.,topoin,lons,start=False)
# setup of basemap ('lcc' = lambert conformal conic).
m = Basemap(-145.5,1.,-2.566,46.352,\
resolution='c',area_thresh=10000.,projection='lcc',\
lat_1=50.,lon_0=-107.)
# transform to nx x ny regularly spaced native projection grid
nx = int((m.xmax-m.xmin)/40000.)+1; ny = int((m.ymax-m.ymin)/40000.)+1
topodat = m.transform_scalar(topoin,lons,lats,nx,ny)
xsize = rcParams['figure.figsize'][0]
fig=figure(figsize=(xsize,m.aspect*xsize))
ax = fig.add_axes([0.1,0.1,0.7,0.7])
im = m.imshow(topodat,cm.jet)
cax = axes([0.875, 0.1, 0.05, 0.7])
colorbar(tickfmt='%d', cax=cax) # draw colorbar
axes(ax) # make the original axes current again
m.drawcoastlines()
m.drawcountries()
m.drawstates()
#m.fillcontinents()
def add_text(rlon, rlat, txt, m=None, **keywords):
show_lat = 1
if ('show_lat' in keywords):
show_lat = keywords['show_lat']
rlon = array(rlon)
rlat = array(rlat)
show_lon = 1
if ('show_lon' in keywords):
show_lon = keywords['show_lon']
if (m == None):
map_proj = 'cyl'
if ('map_proj' in keywords):
map_proj = keywords['map_proj']
lat_0 = 0.0
if ('lat_0' in keywords):
lat_0 = keywords['lat_0']
minlat = -90.0
maxlat = 90.0
if ('minlat' in keywords):
minlat = keywords['minlat']
if ('maxlat' in keywords):
maxlat = keywords['maxlat']
minlon = -180
maxlon = 180.0
if ('minlon' in keywords):
minlon = keywords['minlon']
if ('maxlon' in keywords):
maxlon = keywords['maxlon']
lon_0 = 0
if ('lon_0' in keywords):
lon_0 = keywords['lon_0']
boundinglat = 45
if ('boundinglat' in keywords):
boundinglat = keywords['boundinglat']
if (map_proj == 'npstere' or map_proj == 'spstere'):
m = Basemap(projection=map_proj,
lon_0=lon_0,
boundinglat=boundinglat)
elif (map_proj == 'ortho'):
m = Basemap(projection=map_proj, lon_0=lon_0, lat_0=lat_0)
else:
m=Basemap(llcrnrlon=minlon, llcrnrlat=minlat, \
urcrnrlon=maxlon, urcrnrlat=maxlat,projection=map_proj, lon_0=lon_0, lat_0=lat_0)
if (show_lat == 1):
m.drawparallels(arange(minlat, maxlat + 30.0, 30.),
labels=[1, 0, 0, 0])
if (show_lon == 1):
m.drawmeridians(arange(minlon, maxlon + 60, 60.),
labels=[0, 0, 0, 1])
x, y = m(rlon, rlat)
for i in range(size(rlon)):
text(x[i], y[i], txt[i], fontsize=10)
if ('title' in keywords):
stitle = keywords['title']
title(stitle)
return m
if __version__ <= '0.70':
print 'warning - contour example will not work with this version of matplotlib if axes.patch is not applied'
# read in data on lat/lon grid.
datadict = cPickle.load(open('500hgt.pickle', 'rb'))
hgt = datadict['data']
lons = datadict['lons']
lats = datadict['lats']
# set up map projection (lambert azimuthal equal area).
m = Basemap(-150.,
-20.,
30.,
-20.,
resolution='c',
area_thresh=10000.,
projection='laea',
lat_0=90.,
lon_0=-105.)
# interpolate to map projection grid.
nx = 101
ny = 101
lonsout, latsout = m.makegrid(nx, ny)
hgt = interp(hgt, lons, lats, lonsout, latsout)
dx = (m.xmax - m.xmin) / (nx - 1)
dy = (m.ymax - m.ymin) / (ny - 1)
x = m.xmin + dx * indices((ny, nx))[1, :, :]
y = m.ymin + dy * indices((ny, nx))[0, :, :]
#m = Basemap(lons[0],lats[0],lons[-1],lats[-1],\
x = property(get_xdata)
def get_ydata(self): return self._line.get_ydata()
y = property(get_ydata)
if __name__ == '__main__':
from matplotlib.toolkits.basemap import Basemap
from matplotlib.ticker import FuncFormatter
from pyroms.focus import Focus
m = Basemap(projection='lcc',
resolution='i',
llcrnrlon=5.0,
llcrnrlat= 52.,
urcrnrlon=35.5,
urcrnrlat=68.0,
lat_0=15.00,
lon_0=0.0,
suppress_ticks=False)
fig=pl.figure()
# background color will be used for 'wet' areas.
fig.add_axes([0.1,0.1,0.8,0.8],axisbg='azure')
m.drawcoastlines(linewidth=0.25)
m.fillcontinents(color='beige')
x, y, beta = zip(*[(241782.65384467551, 1019981.3539730886, 1.0),
(263546.12512432877, 686274.79435173667, 0),
(452162.87621465814, 207478.42619936226, 1.0),
(1431519.0837990609, 432367.62942244718, 1.0),
from gdalconst import *
import pylab as p
# download from
# http://edcftp.cr.usgs.gov/pub/data/DEM/250/D/denver-w.gz
gd = gdal.Open("denver-w")
# get data from DEM file
array = gd.ReadAsArray()
# get lat/lon coordinates from DEM file.
coords = gd.GetGeoTransform()
llcrnrlon = coords[0]
urcrnrlon = llcrnrlon + (array.shape[1] - 1) * coords[1]
urcrnrlat = coords[3]
llcrnrlat = urcrnrlat + (array.shape[0] - 1) * coords[5]
# create Basemap instance.
m = Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat, urcrnrlon=urcrnrlon, urcrnrlat=urcrnrlat, projection="cyl")
# create a figure with the right aspect ratio, add an axes
# (leaving room for a colorbar).
fig = p.figure(figsize=(8, m.aspect * 8))
ax = fig.add_axes([0.1, 0.1, 0.75, 0.75])
# plot image from DEM over map.
im = m.imshow(array, origin="upper")
# make a colorbar.
cax = p.axes([0.875, 0.1, 0.05, 0.75]) # setup colorbar axes.
p.colorbar(tickfmt="%d", cax=cax) # draw colorbar
p.axes(ax) # make the original axes current again
# draw meridians and parallels.
m.drawmeridians(p.linspace(llcrnrlon + 0.1, urcrnrlon - 0.1, 5), labels=[0, 0, 0, 1], fmt="%4.2f")
m.drawparallels(p.linspace(llcrnrlat + 0.1, urcrnrlat - 0.1, 5), labels=[1, 0, 0, 0], fmt="%4.2f")
# plot county boundaries from
# http://edcftp.cr.usgs.gov/pub/data/nationalatlas/countyp020.tar.gz
# read in jpeg image to rgba array of normalized floats.
pilImage = Image.open('land_shallow_topo_2048.jpg')
rgba = pil_to_array(pilImage)
rgba = rgba.astype(P.Float32)/255. # convert to normalized floats.
# define lat/lon grid that image spans (projection='cyl').
nlons = rgba.shape[1]; nlats = rgba.shape[0]
delta = 360./float(nlons)
lons = P.arange(-180.+0.5*delta,180.,delta)
lats = P.arange(-90.+0.5*delta,90.,delta)
# create new figure
fig=P.figure()
# define cylindrical equidistant projection.
m = Basemap(projection='cyl',llcrnrlon=-180,llcrnrlat=-90,urcrnrlon=180,urcrnrlat=90,resolution='l')
# plot (unwarped) rgba image.
im = m.imshow(rgba)
# draw coastlines.
m.drawcoastlines(linewidth=0.5,color='0.5')
# draw lat/lon grid lines.
m.drawmeridians(P.arange(-180,180,60),labels=[0,0,0,1],color='0.5')
m.drawparallels(P.arange(-90,90,30),labels=[1,0,0,0],color='0.5')
P.title("Blue Marble image - native 'cyl' projection",fontsize=12)
print 'plot cylindrical map (no warping needed) ...'
# create new figure
fig=P.figure()
# define orthographic projection centered on North America.
m = Basemap(projection='ortho',lat_0=40,lon_0=40,resolution='l')
# transform to nx x ny regularly spaced native projection grid
# in which direction to depart for other points on earth and how far
# it will be to reach that destination.
# The specified point shows up as a red dot in the center of the map.
# This example shows how to use the width and height keywords
# to specify the map projection region (instead of specifying
# the lat/lon of the upper right and lower left corners).
# user enters the lon/lat of the point, and it's name
lon_0 = float(raw_input('input reference lon (degrees):'))
lat_0 = float(raw_input('input reference lat (degrees):'))
location = raw_input('name of location:')
# use these values to setup Basemap instance.
width = 28000000
m = Basemap(width=width,height=width,\
resolution='c',projection='aeqd',\
lat_0=lat_0,lon_0=lon_0)
# draw coasts and fill continents.
m.drawcoastlines(linewidth=0.5)
m.fillcontinents()
# 20 degree graticule.
m.drawparallels(arange(-80, 81, 20))
m.drawmeridians(arange(-180, 180, 20))
# draw a red dot at the center.
xpt, ypt = m(lon_0, lat_0)
m.plot([xpt], [ypt], 'ro')
# draw the title.
title('The World According to Garp in ' + location)
show()
# example demonstrating how to draw a great circle on a map.
from matplotlib.toolkits.basemap import Basemap
from pylab import *
# setup lambert azimuthal map projection.
m = Basemap(llcrnrlon=-100.,llcrnrlat=20.,urcrnrlon=20.,urcrnrlat=60.,\
rsphere=(6378137.00,6356752.3142),\
resolution='c',area_thresh=10000.,projection='merc',\
lat_0=40.,lon_0=-20.,lat_ts=20.)
# make figure with aspect ratio that matches map region.
xsize = rcParams['figure.figsize'][0]
fig = figure(figsize=(xsize, m.aspect * xsize))
fig.add_axes([0.1, 0.1, 0.8, 0.8])
# nylat, nylon are lat/lon of New York
nylat = 40.78
nylon = -73.98
# 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 = arange(10, 90, 20)
m.drawparallels(circles, labels=[1, 1, 0, 1])
# draw meridians
import pylab as p
import matplotlib.numerix as nx
from matplotlib.toolkits.basemap import Basemap as Basemap
from matplotlib.collections import LineCollection
from matplotlib.colors import rgb2hex
import random
# requires pyshapelib from Thuban (http://thuban.intevation.org/).
# cd to libraries/pyshapelib in Thuban source distribution, run
# 'python setup.py install'.
# Lambert Conformal map of lower 48 states.
m = Basemap(llcrnrlon=-119,llcrnrlat=22,urcrnrlon=-64,urcrnrlat=49,
projection='lcc',lat_1=33,lat_2=45,lon_0=-95)
fig=p.figure(figsize=(8,m.aspect*8))
fig.add_axes([0.1,0.1,0.8,0.8])
# draw climate division boundaries.
shp_info = m.readshapefile('divisions','climdivs',drawbounds=True)
print shp_info
# make sure the shapefile has polygons (and not just lines).
if shp_info[1] != 5:
print 'warning: shapefile does not contain polygons'
# choose a color for each climate division (randomly).
colors={}
divnames=[]
print m.climdivs_info[0].keys()
for shapedict in m.climdivs_info:
divname = shapedict['ST']+repr(shapedict['DIV'])
colors[divname] = (random.uniform(0,1),random.uniform(0,1),random.uniform(0,1))
divnames.append(divname)
# cycle through climate divnames, color each one.
import matplotlib.cm as cm
from matplotlib.mlab import load
# read in topo data (on a regular lat/lon grid)
# longitudes go from 20 to 380.
etopo = load('etopo20data.gz')
lons = load('etopo20lons.gz')
lats = load('etopo20lats.gz')
# create figure.
fig = Figure()
canvas = FigureCanvas(fig)
# create axes instance, leaving room for colorbar at bottom.
ax = fig.add_axes([0.125,0.175,0.75,0.75])
# create Basemap instance for Robinson projection.
# set 'ax' keyword so pylab won't be imported.
m = Basemap(projection='robin',lon_0=0.5*(lons[0]+lons[-1]),ax=ax)
# make filled contour plot.
x, y = m(*meshgrid(lons, lats))
cs = m.contourf(x,y,etopo,30,cmap=cm.jet)
# draw coastlines.
m.drawcoastlines()
# draw a line around the map region.
m.drawmapboundary()
# draw parallels and meridians.
m.drawparallels(nx.arange(-60.,90.,30.),labels=[1,0,0,0],fontsize=10)
m.drawmeridians(nx.arange(0.,420.,60.),labels=[0,0,0,1],fontsize=10)
# add a title.
ax.set_title('Robinson Projection')
# add a colorbar.
l,b,w,h = ax.get_position()
cax = fig.add_axes([l, b-0.1, w, 0.03],frameon=False) # setup colorbar axes
for line in file.readlines():
l = line.replace('\n','').split()
ul.append(float(l[0]))
vl.append(float(l[1]))
pl.append(float(l[2]))
u = reshape(array(ul,Float32),(nlats,nlons))
v = reshape(array(vl,Float32),(nlats,nlons))
p = reshape(array(pl,Float32),(nlats,nlons))
lats1 = -90.+dellat*arange(nlats)
lons1 = -180.+dellon*arange(nlons)
lons, lats = meshgrid(lons1, lats1)
# plot vectors in geographical (lat/lon) coordinates.
# north polar projection.
m = Basemap(lon_0=-135,boundinglat=25,
resolution='c',area_thresh=10000.,projection='npstere')
# create a figure, add an axes.
fig=figure(figsize=(8,8))
ax = fig.add_axes([0.1,0.1,0.7,0.7])
# rotate wind vectors to map projection coordinates.
# (also compute native map projections coordinates of lat/lon grid)
# only do Northern Hemisphere.
urot,vrot,x,y = m.rotate_vector(u[36:,:],v[36:,:],lons[36:,:],lats[36:,:],returnxy=True)
# plot filled contours over map.
cs = m.contourf(x,y,p[36:,:],15,cmap=cm.jet)
# plot wind vectors over map.
Q = m.quiver(x,y,urot,vrot) #or specify, e.g., width=0.003, scale=400)
qk = quiverkey(Q, 0.95, 1.05, 25, '25 m/s', labelpos='W')
cax = axes([0.875, 0.1, 0.05, 0.7]) # setup colorbar axes.
colorbar(cax=cax) # draw colorbar
axes(ax) # make the original axes current again
