Skip to content
Back to top
View this page

# Plotting data on a map (Example Gallery)

Following are a series of examples that illustrate how to use Basemap instance methods to plot your data on a map. More examples are included in the doc/examples directory of the basemap source distribution. There are a number of Basemap instance methods for plotting data:

- `contour()`: draw contour lines.

- `contourf()`: draw filled contours.

- `imshow()`: draw an image.

- `pcolor()`: draw a pseudocolor plot.

- `pcolormesh()`: draw a pseudocolor plot (faster version for regular meshes).

- `plot()`: draw lines and/or markers.

- `scatter()`: draw points with markers.

- `quiver()`: draw vectors.

- `barbs()`: draw wind barbs.

- `drawgreatcircle()`: draw a great circle.

Many of these instances methods simply forward to the corresponding matplotlib Axes instance method, with some extra pre/post processing and argument checking. You can also plot on the map directly with the matplotlib pyplot interface, or the OO api, using the Axes instance associated with the Basemap.

For more specifics of how to use the Basemap instance methods, see Basemap API.

Here are the examples (many of which utilize the netcdf4-python module to retrieve datasets over http):

- Plot contour lines on a basemap

    from mpl_toolkits.basemap import Basemap
    import matplotlib.pyplot as plt
    import numpy as np
    # set up orthographic map projection with
    # perspective of satellite looking down at 45N, 100W.
    # use low resolution coastlines.
    map = Basemap(projection='ortho',lat_0=45,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',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,:,:])
    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)
    # contour data over the map.
    cs = map.contour(x,y,wave+mean,15,linewidths=1.5)
    plt.title('contour lines over filled continent background')
    plt.show()

(`Source code`)

- Plot precip with filled contours

    from mpl_toolkits.basemap import Basemap, cm
    # requires netcdf4-python (netcdf4-python.googlecode.com)
    from netCDF4 import Dataset as NetCDFFile
    import os
    import numpy as np
    import matplotlib.pyplot as plt

    # plot rainfall from NWS using special precipitation
    # colormap used by the NWS, and included in basemap.

    ncpath = os.path.join(*3 * [".."] + ["examples", "nws_precip_conus_20061222.nc"])
    nc = NetCDFFile(ncpath)
    # data from http://water.weather.gov/precip/
    prcpvar = nc.variables['amountofprecip']
    data = 0.01*prcpvar[:]
    latcorners = nc.variables['lat'][:]
    loncorners = -nc.variables['lon'][:]
    lon_0 = -nc.variables['true_lon'].getValue()
    lat_0 = nc.variables['true_lat'].getValue()
    # create figure and axes instances
    fig = plt.figure(figsize=(8,8))
    ax = fig.add_axes([0.1,0.1,0.8,0.8])
    # create polar stereographic Basemap instance.
    m = Basemap(projection='stere',lon_0=lon_0,lat_0=90.,lat_ts=lat_0,\
                llcrnrlat=latcorners[0],urcrnrlat=latcorners[2],\
                llcrnrlon=loncorners[0],urcrnrlon=loncorners[2],\
                rsphere=6371200.,resolution='l',area_thresh=10000)
    # draw coastlines, state and country boundaries, edge of map.
    m.drawcoastlines()
    m.drawstates()
    m.drawcountries()
    # draw parallels.
    parallels = np.arange(0.,90,10.)
    m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10)
    # draw meridians
    meridians = np.arange(180.,360.,10.)
    m.drawmeridians(meridians,labels=[0,0,0,1],fontsize=10)
    ny = data.shape[0]; nx = data.shape[1]
    lons, lats = m.makegrid(nx, ny) # get lat/lons of ny by nx evenly space grid.
    x, y = m(lons, lats) # compute map proj coordinates.
    # draw filled contours.
    clevs = [0,1,2.5,5,7.5,10,15,20,30,40,50,70,100,150,200,250,300,400,500,600,750]
    cs = m.contourf(x,y,data,clevs,cmap=cm.s3pcpn)
    # add colorbar.
    cbar = m.colorbar(cs,location='bottom',pad="5%")
    cbar.set_label('mm')
    # add title
    plt.title(prcpvar.long_name+' for period ending '+prcpvar.dateofdata)
    plt.show()

(`Source code`)

- Plot hurricane tracks from a shapefile

    """
    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://nationalatlas.gov/mld/huralll.html
    """
    import os
    import numpy as np
    import matplotlib.pyplot as plt
    from mpl_toolkits.basemap import 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.,
                resolution ='l',area_thresh=1000.)
    # read shapefile.
    shp_path = os.path.join(*3 * [".."] + ["examples", "huralll020"])
    shp_info = m.readshapefile(shp_path,'hurrtracks',drawbounds=False)
    # 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:
            # only use named storms.
            if name != 'NOT NAMED':  names.append(name)
    # 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)
            # show part of track where storm > Cat 4 as thick red.
            if cat in ['H4','H5']:
                m.plot(xx,yy,linewidth=1.5,color='r')
            elif cat in ['H1','H2','H3']:
                m.plot(xx,yy,color='k')
    # draw coastlines, meridians and parallels.
    m.drawcoastlines()
    m.drawcountries()
    m.drawmapboundary(fill_color='#99ffff')
    m.fillcontinents(color='#cc9966',lake_color='#99ffff')
    m.drawparallels(np.arange(10,70,20),labels=[1,1,0,0])
    m.drawmeridians(np.arange(-100,0,20),labels=[0,0,0,1])
    plt.title('Atlantic Hurricane Tracks (Storms Reaching Category 4, 1851-2004)')
    plt.show()

(`Source code`)

- Draw great circle between NY and London.

    from mpl_toolkits.basemap import Basemap
    import numpy as np
    import matplotlib.pyplot as plt
    # create new figure, axes instances.
    fig=plt.figure()
    ax=fig.add_axes([0.1,0.1,0.8,0.8])
    # setup mercator map projection.
    m = Basemap(llcrnrlon=-100.,llcrnrlat=20.,urcrnrlon=20.,urcrnrlat=60.,\
                rsphere=(6378137.00,6356752.3142),\
                resolution='l',projection='merc',\
                lat_0=40.,lon_0=-20.,lat_ts=20.)
    # 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 great circle route between NY and London
    m.drawgreatcircle(nylon,nylat,lonlon,lonlat,linewidth=2,color='b')
    m.drawcoastlines()
    m.fillcontinents()
    # draw parallels
    m.drawparallels(np.arange(10,90,20),labels=[1,1,0,1])
    # draw meridians
    m.drawmeridians(np.arange(-180,180,30),labels=[1,1,0,1])
    ax.set_title('Great Circle from New York to London')
    plt.show()

(`Source code`)

- Draw day-night terminator on a map.

    import os
    import time
    import datetime
    import numpy as np
    from mpl_toolkits.basemap import Basemap
    import matplotlib.pyplot as plt
    # miller projection
    map = Basemap(projection='mill',lon_0=180)
    # plot coastlines, draw label meridians and parallels.
    map.drawcoastlines()
    map.drawparallels(np.arange(-90,90,30),labels=[1,0,0,0])
    map.drawmeridians(np.arange(map.lonmin,map.lonmax+30,60),labels=[0,0,0,1])
    # fill continents 'coral' (with zorder=0), color wet areas 'aqua'
    map.drawmapboundary(fill_color='aqua')
    map.fillcontinents(color='coral',lake_color='aqua')
    # shade the night areas, with alpha transparency so the
    # map shows through. Use current time in UTC.
    date = datetime.datetime.utcfromtimestamp(
            int(os.environ.get('SOURCE_DATE_EPOCH', time.time())))
    CS=map.nightshade(date)
    plt.title('Day/Night Map for %s (UTC)' % date.strftime("%d %b %Y %H:%M:%S"))
    plt.show()

(`Source code`)