Gridded Datasets I#

GeoViews is designed to make full use of multidimensional gridded datasets stored in netCDF or other common formats, via the xarray and iris interfaces in HoloViews. This notebook will demonstrate how to load data using both of these data backends, along with some of their individual quirks. The data used in this notebook was originally shipped as part of the SciTools/iris-sample-data repository, but a smaller netCDF file is included as part of the GeoViews so that it can be used with xarray as well.

import iris
import numpy as np
import xarray as xr
import holoviews as hv
import geoviews as gv
import geoviews.feature as gf

from cartopy import crs
from geoviews import opts

gv.extension('matplotlib')

gv.output(size=150)

A Simple example#

To visualize the datasets, in a single line of code we can specify that we want to view it as a collection of Images indexed by longitude and latitude (a HoloViews HoloMap of gv.Image elements):

xr_dataset.to(gv.Image, ['longitude', 'latitude'])

You can see that the time dimension was automatically mapped to a slider, because we did not map it onto one of the other available dimensions (x, y, or color, in this case). You can drag the slider to view the surface temperature at different times. The example would work just the same for the iris_dataset.

Now let us load a cube showing the pre-industrial air temperature:

pre_industrial = xr.open_dataset('../data/pre-industrial.nc').load()

air_temperature = gv.Dataset(pre_industrial, ['longitude', 'latitude'], 'air_temperature')
air_temperature

:Dataset   [longitude,latitude]   (air_temperature)

Note that we have the air_temperature available over longitude and latitude but not the time dimensions. As a result, this cube is a single frame (at right below) when visualized as an Image:

gv.Image(air_temperature)

The following more complicated example shows how complex interactive plots can be generated with relatively little code, and also demonstrates how different HoloViews elements can be combined together. In the following visualization, the black dot denotes a specific longitude, latitude location (0,10), and the curve is a sample of the surface_temperature at that location. The curve is unaffected by the time slider because it already lays out time along the x axis:

temp_curve = hv.Curve(xr_dataset.select(longitude=0, latitude=10), kdims=['time'])
temp_map = xr_dataset.to(gv.Image,['longitude', 'latitude']) * gv.Points([(0,10)])
(temp_map + temp_curve).opts(
    opts.Curve(aspect=2, xticks=4, xrotation=15),
    opts.Points(color='k', global_extent=True))

Overlaying data and normalization#

Let’s view the surface temperatures together with the global coastline:

(xr_dataset.to.image(['longitude', 'latitude']) * gf.coastline).opts(
    opts.Image(projection=crs.Geostationary(), cmap='Greens', xaxis=None, yaxis=None))

Notice that every frame individually uses the full dynamic range of the Greens color map. This is because normalization is set to +framewise at the top of the notebook, which means every frame is normalized independently. This sort of normalization can be computed on an as-needed basis, using whatever values are found in the current data being shown in a given frame, but it won’t let you see how different frames compare to each other.

To control normalization, we need to decide on the normalization limits. Let’s see the maximum temperature in the cube, and use it to set a normalization range by using the redim method:

max_surface_temp = xr_dataset.range('surface_temperature')[1]
print(max_surface_temp)
srfc_temps = xr_dataset.redim.range(surface_temperature=(300, max_surface_temp)).to(gv.Image,['longitude', 'latitude'])

(srfc_temps * gf.coastline).opts(
    opts.Image(projection=crs.Geostationary(), cmap='Greens', xaxis=None, yaxis=None))

317.331787109375

By specifying the normalization range we can reveal different aspects of the data. In the example above we can see a cooling effect over time as the dark green areas close to the top of the normalization range (317K) vanish. Values outside this range are clipped to the ends of the color map.

Lastly, here is a demo of a conversion from surface_temperature to FilledContours:

xr_dataset.to(gv.FilledContours,['longitude', 'latitude']) * gf.coastline

As you can see, it’s quite simple to expose any data you like from your Iris cube or xarray, easily and flexibly creating interactive or static visualizations.

This web page was generated from a Jupyter notebook and not all interactivity will work on this website. Right click to download and run locally for full Python-backed interactivity.

Right click to download this notebook from GitHub.

Gridded Datasets I#

Loading our data#

XArray#

Iris#

A Simple example#

Overlaying data and normalization#