-Advanced Visualization Cookbook
-
-
-
This Project Pythia Cookbook covers advanced visualization techniques building upon and combining various Python packages.
-Motivation
-The possibilities of data visualization in Python are almost endless. Already using matplotlib the workhorse behind many visualization packages, the user has a lot of customization options available to them. cartopy, metpy, seaborn, geocat-viz, and datashader are all also great packages that can offer unique additions to your Python visualization toolbox.
This Cookbook will house various visualization workflow examples that use different visualization packages, highlight the differences in functionality between the packages, any noteable syntax distinctions, and demonstrate combining tools to achieve a specific outcome.
-Structure
-This cookbook is broken up into a few sections - a “Basics of Geoscience Visualization” intro that compares different visualization packages and plot elements, and then example workflows of advanced visualization applications that are further subdivided.
-Basics of Geoscience Visualization
-Here we introduce the basics of geoscience visualization, the elements of a plot, different types of plots, and some unique considerations when dealing with model and measured data. Here we also share a comparison of different visualization packages available to the Scientific Python programmer.
-Specialty Plots
-There are some plot types that are unique to atmospheric science such as Taylor Diagrams or Skew-T plots. Here we will use metpy and geocat-viz to demonstrate these specialty plots.
Visualization of Structured Grids
-In this section we will demonstrate how to visualize data that is on a structured grid. Here we will have workflows that utilize packages such as cartopy and geocat-viz.
Visualization of Unstructured Grids
-There are lots of compelling reasons to use unstructured data. In this section we will go over these points and demonstrate how to visualizate unstructured grids using uxarray.
Interactive Visualization
-Some plots allow users to iteract with them by toggling certain constants or changing the viewing angle. Here we use datashader to iteract with some plots.
3D Visualization
-A lot of geoscience data is 3-dimensional. Here we discuss tools such as vapor that are designed for multidimensional data visualization.
Running the Notebooks
-You can either run the notebook using Binder or on your local machine.
-Running on Binder
-The simplest way to interact with a Jupyter Notebook is through -Binder, which enables the execution of a -Jupyter Book in the cloud. The details of how this works are not -important for now. All you need to know is how to launch a Pythia -Cookbooks chapter via Binder. Simply navigate your mouse to -the top right corner of the book chapter you are viewing and click -on the rocket ship icon, (see figure below), and be sure to select -“launch Binder”. After a moment you should be presented with a -notebook that you can interact with. I.e. you’ll be able to execute -and even change the example programs. You’ll see that the code cells -have no output at first, until you execute them by pressing -Shift+Enter. Complete details on how to interact with -a live Jupyter notebook are described in Getting Started with -Jupyter.
-Running on Your Own Machine
-If you are interested in running this material locally on your com
--
-
Clone the
-https://github.com/ProjectPythia/advanced-viz-cookbookrepository:--git clone https://github.com/ProjectPythia/advanced-viz-cookbook.git -
-Move into the
-advanced-viz-cookbookdirectory--cd advanced-viz-cookbook -
-Create and activate your conda environment from the
-environment.ymlfile--conda env create -f environment.yml -conda activate advanced-viz-cookbook -
-Move into the
-notebooksdirectory and start up Jupyterlab--cd notebooks/ -jupyter lab -
-
-
-# Advanced Visualization Cookbook
-
-[](https://github.com/ProjectPythia/advanced-viz-cookbook/actions/workflows/nightly-build.yaml)
-[](https://binder.projectpythia.org/v2/gh/ProjectPythia/advanced-viz-cookbook/main?labpath=notebooks)
-[](https://zenodo.org/badge/latestdoi/671205314)
-
-This Project Pythia Cookbook covers advanced visualization techniques building upon and combining various Python packages.
-
-## Motivation
-
-The possibilities of data visualization in Python are almost endless. Already using `matplotlib` the workhorse behind many visualization packages, the user has a lot of customization options available to them. `cartopy`, `metpy`, `seaborn`, `geocat-viz`, and `datashader` are all also great packages that can offer unique additions to your Python visualization toolbox.
-
-This Cookbook will house various visualization workflow examples that use different visualization packages, highlight the differences in functionality between the packages, any noteable syntax distinctions, and demonstrate combining tools to achieve a specific outcome.
-
-## Authors
-
-[Julia Kent](@jukent), [John Clyne](@clyne)
-
-### Contributors
-
-![\"Matplotlib](\"images/logos/matplotlib.svg\")
\n",
- "\n",
- "Matplotlib is the workhorse of Python visualization needs. It is a comprehensive plotting library that has the capacity to make static, animated, or interactive visualizations. It is hard to imagine plotting in Python without first getting comfortable with Matplotlib. Be sure to check out the [Matplotlib documentation](https://matplotlib.org/) as well as the [Pythia foundations chapter on Matplotlib](https://foundations.projectpythia.org/core/matplotlib.html) for guidance.\n",
- "\n",
- "Matplotlib's syntax should feel familiar to anyone who has plotted data in Matlab.\n",
- "\n",
- "Here is a [simple plotting example from Matplotlib](https://matplotlib.org/stable/gallery/lines_bars_and_markers/simple_plot.html):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import matplotlib.pyplot as plt\n",
- "import numpy as np\n",
- "\n",
- "# Data for plotting\n",
- "t = np.arange(0.0, 2.0, 0.01)\n",
- "s = 1 + np.sin(2 * np.pi * t)\n",
- "\n",
- "fig, ax = plt.subplots()\n",
- "ax.plot(t, s)\n",
- "\n",
- "ax.set(xlabel='time (s)', ylabel='voltage (mV)',\n",
- " title='About as simple as it gets, folks')\n",
- "ax.grid()\n",
- "\n",
- "plt.show()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Cartopy\n",
- "\n",
- "![\"Cartopy](\"images/logos/cartopy.jpeg\")
\n",
- "\n",
- "Cartopy is a Python package for plotting data on the globe. It is the go-to package for plotting maps, dealing with different projections, and adding surface features to your plot. Cartopy is buit on top of [PROJ](https://proj.org/en/9.2/), NumPy and [Shapely](https://shapely.readthedocs.io/en/stable/manual.html), and Matplotlib. To learn more about what Cartopy can do, check out the [Cartopy documentation](https://scitools.org.uk/cartopy/docs/latest/) and the [Pythia foundations Cartopy chapter](https://foundations.projectpythia.org/core/cartopy.html).\n",
- "\n",
- "You may have heard about [Basemap](https://matplotlib.org/basemap/index.html), another geoscience plotting library, which was deprecated in favor of Cartopy.\n",
- "\n",
- "Here is a [simple plotting example from Cartopy](https://scitools.org.uk/cartopy/docs/v0.15/matplotlib/intro.html):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import cartopy.crs as ccrs\n",
- "\n",
- "ax = plt.axes(projection=ccrs.PlateCarree())\n",
- "ax.coastlines()\n",
- "\n",
- "plt.show()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## GeoCAT-Viz\n",
- "\n",
- "![\"GeoCAT](\"images/logos/geocat.png\")
\n",
- "\n",
- "The GeoCAT team at the National Center for Atmospheric Research (NCAR) aims to help scientists transitioning from [NCL](https://www.ncl.ucar.edu/) to Python. Out of this team come two different visualization aids: the [GeoCAT-examples Visualization Gallery](https://geocat-examples.readthedocs.io/en/latest/) which contains tons of different plotting examples that you can use as a starting place for your figures, and the [GeoCAT-Viz package (documentation)](https://geocat-viz.readthedocs.io/en/latest/) which contains many convenience functions that formerly existed in NCL or for making Python plots look publication-ready."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## MetPy\n",
- "\n",
- "![\"Metpy](\"images/logos/metpy.png\")
\n",
- "\n",
- "Metpy is a collection of tools for data reading, analysis, and visualization with weather data. Matplotlib offers some useful functionality for unique plots such as Skew-T diagrams, as well as declaritive plotting functionality. Check out the [MetPy documentation](https://unidata.github.io/MetPy/latest/index.html).\n",
- "\n",
- "Here is a simple Skew-T plot from their [Getting Started documentation](https://unidata.github.io/MetPy/latest/userguide/startingguide.html):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import metpy.calc as mpcalc\n",
- "from metpy.plots import SkewT\n",
- "from metpy.units import units\n",
- "\n",
- "fig = plt.figure(figsize=(9, 9))\n",
- "skew = SkewT(fig)\n",
- "\n",
- "# Create arrays of pressure, temperature, dewpoint, and wind components\n",
- "p = [902, 897, 893, 889, 883, 874, 866, 857, 849, 841, 833, 824, 812, 796, 776, 751,\n",
- " 727, 704, 680, 656, 629, 597, 565, 533, 501, 468, 435, 401, 366, 331, 295, 258,\n",
- " 220, 182, 144, 106] * units.hPa\n",
- "t = [-3, -3.7, -4.1, -4.5, -5.1, -5.8, -6.5, -7.2, -7.9, -8.6, -8.9, -7.6, -6, -5.1,\n",
- " -5.2, -5.6, -5.4, -4.9, -5.2, -6.3, -8.4, -11.5, -14.9, -18.4, -21.9, -25.4,\n",
- " -28, -32, -37, -43, -49, -54, -56, -57, -58, -60] * units.degC\n",
- "td = [-22, -22.1, -22.2, -22.3, -22.4, -22.5, -22.6, -22.7, -22.8, -22.9, -22.4,\n",
- " -21.6, -21.6, -21.9, -23.6, -27.1, -31, -38, -44, -46, -43, -37, -34, -36,\n",
- " -42, -46, -49, -48, -47, -49, -55, -63, -72, -88, -93, -92] * units.degC\n",
- "\n",
- "# Calculate parcel profile\n",
- "prof = mpcalc.parcel_profile(p, t[0], td[0]).to('degC')\n",
- "u = np.linspace(-10, 10, len(p)) * units.knots\n",
- "v = np.linspace(-20, 20, len(p)) * units.knots\n",
- "\n",
- "skew.plot(p, t, 'r')\n",
- "skew.plot(p, td, 'g')\n",
- "skew.plot(p, prof, 'k') # Plot parcel profile\n",
- "skew.plot_barbs(p[::5], u[::5], v[::5])\n",
- "\n",
- "skew.ax.set_xlim(-50, 15)\n",
- "skew.ax.set_ylim(1000, 100)\n",
- "\n",
- "# Add the relevant special lines\n",
- "skew.plot_dry_adiabats()\n",
- "skew.plot_moist_adiabats()\n",
- "skew.plot_mixing_lines()\n",
- "\n",
- "plt.show();"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## VAPOR\n",
- "\n",
- "![\"VAPOR](\"images/logos/vapor.png\")
\n",
- "\n",
- "VAPOR stands for the Visualization and Analysis Platform for Ocean, Atmosphere, and Solar Researchers and is another project from NCAR. VAPOR provides an interactive 3D visualization environment. Learn more at the [VAPOR documentation](https://www.vapor.ucar.edu/) and the [VAPOR Pythia Cookbook](https://projectpythia.org/vapor-python-cookbook/README.html). VAPORrequires a GPU-enabled environment to run."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Plotly\n",
- "\n",
- "![\"Plotly](\"images/logos/plotly.png\")
\n",
- "\n",
- "Plotly is another choice for interactive plotting. Plotly has functionality in several languags. Here is the [Plotly Python documentation](https://plotly.com/python/).\n",
- "\n",
- "Here is an example using their \"Express\" functionality:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import plotly.express as px\n",
- "\n",
- "fig = px.scatter(x=[0, 1, 2, 3, 4], y=[0, 1, 4, 9, 16])\n",
- "fig.show()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Seaborn\n",
- "\n",
- "![\"Seaborn](\"images/logos/seaborn.svg\")
\n",
- "\n",
- "Seaborn is a high level interactive interface for creating statistical visualizations built on matplotlib. Check out the [Seaborn documentation](https://seaborn.pydata.org/).\n",
- "\n",
- "Here is their [heatmap example](https://seaborn.pydata.org/examples/spreadsheet_heatmap.html):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import seaborn as sns\n",
- "sns.set_theme()\n",
- "\n",
- "# Load the example flights dataset and convert to long-form\n",
- "flights_long = sns.load_dataset(\"flights\")\n",
- "flights = flights_long.pivot(index=\"month\", columns=\"year\", values=\"passengers\")\n",
- "\n",
- "# Draw a heatmap with the numeric values in each cell\n",
- "f, ax = plt.subplots(figsize=(9, 6))\n",
- "sns.heatmap(flights, annot=True, fmt=\"d\", linewidths=.5, ax=ax)\n",
- "\n",
- "plt.show();"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Bokeh\n",
- "\n",
- "![\"Bokeh](\"images/logos/bokeh.jpeg\")
\n",
- "\n",
- "Bokeh is a Javascript-powered tool for creating interactive visualizations in modern web browsers. Check out the [Bokeh documentation](https://bokeh.org/).\n",
- "\n",
- "Here is [scatter plot example](https://docs.bokeh.org/en/latest/docs/examples/basic/scatters/color_scatter.html):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "from bokeh.plotting import figure, show\n",
- "\n",
- "N = 4000\n",
- "x = np.random.random(size=N) * 100\n",
- "y = np.random.random(size=N) * 100\n",
- "radii = np.random.random(size=N) * 1.5\n",
- "colors = np.array([(r, g, 150) for r, g in zip(50+2*x, 30+2*y)], dtype=\"uint8\")\n",
- "\n",
- "TOOLS=\"hover,crosshair,pan,wheel_zoom,zoom_in,zoom_out,box_zoom,undo,redo,reset,tap,save,box_select,poly_select,lasso_select,examine,help\"\n",
- "\n",
- "p = figure(tools=TOOLS)\n",
- "\n",
- "p.scatter(x, y, radius=radii,\n",
- " fill_color=colors, fill_alpha=0.6,\n",
- " line_color=None)\n",
- "\n",
- "show(p)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## UXarray\n",
- "\n",
- "![\"UXarray](\"images/logos/uxarray.png\")
\n",
- "\n",
- "UXarray specializes in unstructured grids, built around [UGRID conventions](https://ugrid-conventions.github.io/ugrid-conventions/) and Xarray syntax. See the [UXarray documentation](https://uxarray.readthedocs.io/en/latest/)."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## hvPlot\n",
- "\n",
- "![\"Datashader](\"images/logos/hvplot.svg\")
\n",
- "\n",
- "hvPlot wraps both [Datashader](https://datashader.org/), a graphics pipeline, and [Holoviews](https://holoviews.org/), a tool for bundling data and metadata for intuitive interactive plotting, at a higher level. All 3 tools are by [Holoviz](https://holoviz.org/). Reference the [hvPlot documentation](https://hvplot.holoviz.org/).\n",
- "\n",
- "Here is a simple example from their [user guide](https://hvplot.holoviz.org/user_guide/Introduction.html):"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import pandas as pd\n",
- "import hvplot.pandas\n",
- "\n",
- "pd.options.plotting.backend = 'holoviews'\n",
- "\n",
- "index = pd.date_range('1/1/2000', periods=1000)\n",
- "df = pd.DataFrame(np.random.randn(1000, 4), index=index, columns=list('ABCD')).cumsum()\n",
- "\n",
- "df.plot()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "This useful diagram from [hvPlot's documentation](https://hvplot.holoviz.org/index.html) details how different high-level tools for data visualization interact.\n",
- "\n",
- "![\"Datashader](\"images/hvplot_diagram.svg\")
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Summary\n",
- "\n",
- "Each Python plotting library offers a slightly different niche in the data visualization world. Some are better for creating publication figures (matplotlib, cartopy, metpy, geocat-viz, uxarray) while others offer interactive functionality that is great for websites, demonstrations, and other forms of engagement (holoviews, seaborn, plotly, bokeh, and vapor). Hopefully the mini examples on this page allow you to play around and see which user interfaces you like best for your visualization needs.\n",
- "\n",
- "\n",
- "### What's next?\n",
- "\n",
- "Next up let's discuss elements of [good data visualization](good-viz)."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Resources and references\n",
- "\n",
- "- [Matplotlib documentation](https://matplotlib.org/)\n",
- "- [Cartopy documentation](https://scitools.org.uk/cartopy/docs/latest/)\n",
- "- [GeoCat-examples Visualization Gallery](https://geocat-examples.readthedocs.io/en/latest/)\n",
- "- [GeoCAT-Viz documentation](https://geocat-viz.readthedocs.io/en/latest/)\n",
- "- [MetPy documentation](https://unidata.github.io/MetPy/latest/index.html)\n",
- "- [Vapor documentation](https://www.vapor.ucar.edu/)\n",
- "- [Plotly Python documentation](https://plotly.com/python/)\n",
- "- [Seaborn documentation](https://seaborn.pydata.org/)\n",
- "- [Bokeh documentation](https://bokeh.org/)\n",
- "- [UXarray documentation](https://uxarray.readthedocs.io/en/latest/)\n",
- "- [hvPlot documentation](https://hvplot.holoviz.org/index.html)\n",
- "- [Holoviews documentation](https://holoviews.org/)\n",
- "- [Datashader documentation](https://datashader.org/)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3 (ipykernel)",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.10.12"
- },
- "nbdime-conflicts": {
- "local_diff": [
- {
- "diff": [
- {
- "diff": [
- {
- "key": 0,
- "op": "addrange",
- "valuelist": [
- "Python 3"
- ]
- },
- {
- "key": 0,
- "length": 1,
- "op": "removerange"
- }
- ],
- "key": "display_name",
- "op": "patch"
- }
- ],
- "key": "kernelspec",
- "op": "patch"
- }
- ],
- "remote_diff": [
- {
- "diff": [
- {
- "diff": [
- {
- "key": 0,
- "op": "addrange",
- "valuelist": [
- "Python3"
- ]
- },
- {
- "key": 0,
- "length": 1,
- "op": "removerange"
- }
- ],
- "key": "display_name",
- "op": "patch"
- }
- ],
- "key": "kernelspec",
- "op": "patch"
- }
- ]
- },
- "toc-autonumbering": false
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/_preview/21/_sources/notebooks/good-viz.ipynb b/_preview/21/_sources/notebooks/good-viz.ipynb
deleted file mode 100644
index c7ce441..0000000
--- a/_preview/21/_sources/notebooks/good-viz.ipynb
+++ /dev/null
@@ -1,325 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# What Makes for Good Data Visualization?"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Overview\n",
- "What Makes a Good Visualization? We want graphics to be eye catching and informative. In this chapter we'll discuss different aspects that can affect the quality of your figures and specific considerations relevant to the geosciences.\n",
- "\n",
- "1. The Importance of Data Visualization\n",
- "1. Publication Ready Figures\n",
- "1. The Problem with Rainbow Colormaps\n",
- "1. Misleading Visualizations"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Prerequisites\n",
- "\n",
- "| Concepts | Importance | Notes |\n",
- "| --- | --- | --- |\n",
- "| [Matplotlib](https://foundations.projectpythia.org/core/matplotlib.html) | Necessary | |\n",
- "| [Cartopy](https://foundations.projectpythia.org/core/cartopy.html) | Necessary | |\n",
- "\n",
- "- **Time to learn**: 3 hours\n",
- "---"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import matplotlib as mpl\n",
- "import matplotlib.pyplot as plt\n",
- "import numpy as np\n",
- "import geocat.viz as gv"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## The Importance of Data Visualization\n",
- "\n",
- "It is important to use pictures to show data because we can visually detect patterns that could be lost in statistical analysis. All scientific disciplines use data visualizations to communicate concepts. \n",
- "\n",
- "Here we have a figure from [Autodesk](https://www.research.autodesk.com/publications/same-stats-different-graphs/) that shows a \"Datasaurus\" and 12 other datasets that share the same statistical information (mean, standard deviation, etc). We can see immediately that visually are telling very different stories: be it a dinosaur, a star, an oval, concentric ovals, or a series of lines (perhaps weather fronts).\n",
- "\n",
- "![\"Same](\"images/same_stats.png\")
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Publication Ready Figures\n",
- "\n",
- "For your figure to be publication rady, you probably want to change some of Matplotlib's default plotting settings: selecting fontsizes for your titles and labels, changing figure sizes, or subplot/colormap layout.\n",
- "\n",
- "To demonstrate this, let's look at an example:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# fake data\n",
- "x = [0, 1, 2, 3, 4, 5]\n",
- "y = [0, 3, 6, 9, 12, 15]\n",
- " \n",
- "# plot\n",
- "plt.plot(x, y)\n",
- "\n",
- "# annotate\n",
- "plt.title('Title')\n",
- "plt.xlabel('X Label')\n",
- "plt.ylabel('Y Label')\n",
- "\n",
- "plt.show();"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Now let's show some customization options:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# fake data\n",
- "x = [0, 1, 2, 3, 4, 5]\n",
- "y = [0, 3, 6, 9, 12, 15]\n",
- " \n",
- "# plot\n",
- "plt.plot(x, y, '--', color='red')\n",
- "\n",
- "# annotate\n",
- "plt.title('Title', fontsize=20)\n",
- "plt.xlabel('X Label', fontsize=16)\n",
- "plt.ylabel('Y Label', fontsize=16)\n",
- "\n",
- "plt.show();"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Matplotlib Global Parameters\n",
- "\n",
- "Matplotlib has defaults for fontsizes and all sorts of attributes of a plot. Instead of setting your fontsize in every script, it is possible to set global parameters to change the default values of these attributes.\n",
- "\n",
- "You can veiw the globoal parameters options and their current settings with:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "mpl.rcParams.keys"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "To change any given parameter you would use the following command (replacing your parameter and value, of course):"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "```\n",
- "mpl.rcParams['font.family'] = 'Arial'\n",
- "```"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Using GeoCAT-Viz\n",
- "\n",
- "The GeoCAT-Viz package also has many utility functions for making your plots looks publication ready in fewer lines of code. The defaults of GeoCAT-viz keword-arguments are set to resemble the style of NCL."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# fake data\n",
- "x = [0, 1, 2, 3, 4, 5]\n",
- "y = [0, 3, 6, 9, 12, 15]\n",
- " \n",
- "# plot\n",
- "plt.plot(x, y)\n",
- "\n",
- "# annotate\n",
- "plt.title('Title')\n",
- "plt.xlabel('X Label')\n",
- "plt.ylabel('Y Label')\n",
- "\n",
- "gv.set_titles_and_labels(plt.gca())\n",
- "\n",
- "plt.show();"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## The Problem with Rainbow Colormaps\n",
- "\n",
- "Rainbow colormaps are visually beautiful, but are falling out of favor because\n",
- "1. They are not colorblind friendly and\n",
- "2. They do not print out in grayscale in a meaningful way.\n",
- "\n",
- "Both of these issues can be addressed by bing careful about you colormaps lightness-values.\n",
- "\n",
- "Some colormaps options are perceptually uniform (the same lightness value), sequentially ordered (goes from lighter to darker), or diverging (lightest or darkest at a set point and uniformly changes lightness going out). A rainbow colormap however is lighter or darker in arbitrary places and it affects how we interpret data (especially if it was printed out in grayscale).\n",
- "\n",
- "For example, from [Matplotlib's Choosing a Colormap documentation](https://matplotlib.org/stable/tutorials/colors/colormaps.html) here are some \"good\" colormaps:\n",
- "\n",
- "![\"Matplotlib](\"https://matplotlib.org/stable/_images/sphx_glr_colormaps_016_2_00x.png\")
\n",
- "\n",
- "And here are miscellaneous colormaps:\n",
- "\n",
- "![\"Matplotlib](\"https://matplotlib.org/stable/_images/sphx_glr_colormaps_021_2_00x.png\")
\n",
- "\n",
- "Looking at the colors in grayscale helps to understand why we might prefer a sequentially ordered colormap. Some grayscale values are duplicated and the reader will not know if it is a high or low value.\n",
- "\n",
- "Another consideration that can help those who are visually impaired is to make sure your figure comments are substantial. Use words to paint the picture of what is displayed, not just the conclusions you want the reader to get."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Misleading Visualizations\n",
- "\n",
- "The scales or colors we choose to use for data visualization affect how people interpret figures. You should strive to make your visualizations as accurate and as informative as possible. Here are some examples that demonstrate just how different a figure can look based on these choices you make. Do not intentionally mislead your audience!\n",
- "\n",
- "Perhaps the most common data visualization manipulation is to change the Y-scale. If a plot does not begin at 0, small changes in magnitude can be exhaggerated. Similarly a logarithmic scale will amplify changes. This is not always disingenuous, sometimes these changes are what you want to highlight, the pattern you want to draw attention to. Just make sure it is appropriate for your use case and documented. Alternatively, extending the Y-axis too large has the opposite affect and smooths out the differences in data."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "x = [1, 2, 3, 4, 5]\n",
- "y = [1101, 1011, 1111, 1070, 1050]\n",
- "\n",
- "\n",
- "fig, (ax1, ax2, ax3, ax4) = plt.subplots(4)\n",
- "fig.tight_layout()\n",
- "\n",
- "ax1.bar(x,y)\n",
- "ax1.set_title(\"Default Y-Scale Starts at 0\")\n",
- "\n",
- "ax2.bar(x,y)\n",
- "ax2.set_ylim(1000)\n",
- "ax2.set_title(\"Y-Scale Starts at 1000\")\n",
- "\n",
- "ax3.bar(x,y)\n",
- "ax3.set_yscale(\"log\")\n",
- "ax3.set_title(\"Y-Scale is Logarithmic\");\n",
- "\n",
- "ax4.bar(x,y)\n",
- "ax4.set_ylim(0, 2000)\n",
- "ax4.set_title(\"Y-Scale is Extended\");"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Other examples of data visualization manipulation include improper scaling, cherry picking a small non-representative subset of the data to display, displaying pie charts at a slant (pie charts are hard to interpet accurately as is), and unusing unexpected colormaps."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Summary\n",
- "It is important to have accurate, engaging, and representative data visualization to accumpany your research, both for data exploration as part of the scientific process, for communication of results, and education/outreach efforts. Visually we pick up on patterns that statistics alone may not convey. However, an over reliance on data visualization can make science less accessible to those with vision disabilities. It is important to be cognicent of the patterns our minds pick up, be it based on color or y-axis scaling, so that we can avoid misleading our audience and more accurately convey the narrative inherent to the data.\n",
- "\n",
- "### What's next?\n",
- "\n",
- "[Plot Elements](plot-elements)\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Resources and references\n",
- "\n",
- "- [Autodesk](https://www.research.autodesk.com/publications/same-stats-different-graphs/)\n",
- "- [Matplotlib's Choosing a Colormap documentation](https://matplotlib.org/stable/tutorials/colors/colormaps.html)\n",
- "- [GeoCAT-examples Gallery](https://geocat-examples.readthedocs.io/en/latest/)\n",
- "- [NWSC Script](https://docs.google.com/document/d/1PxJBbYJsI5nmR9pDQmcRM0ZghRPSI_xlzGVhw3AEUms/edit)\n",
- "- [Beyond Visuals: Examining the Experiences of Geoscience\n",
- "Professionals With Vision Disabilities in Accessing Data Visualizations](https://arxiv.org/pdf/2207.13220.pdf)\n",
- "- [Same Stats Different Graphs: Generating Datasets with Varied Appearance and\n",
- "Identical Statistics through Simulated Annealing](https://www.research.autodesk.com/app/uploads/2023/03/same-stats-different-graphs.pdf_rec2hRjLLGgM7Cn2T.pdf)\n",
- "- Alberto Cairo's How Charts Lie: Getting Smarter about Visual Information\n",
- "- [Misleading Data Visualization – What to Avoid](https://blog.coupler.io/misleading-data-visualization-examples/#:~:text=A%20very%20common%20misleading%20data,truncated%20graph%20might%20distort%20data.)"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "advanced-viz-cookbook",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.10.12"
- },
- "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/_preview/21/_sources/notebooks/how-to-cite.md b/_preview/21/_sources/notebooks/how-to-cite.md
deleted file mode 100644
index e2ca57e..0000000
--- a/_preview/21/_sources/notebooks/how-to-cite.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# How to Cite This Cookbook
-
-The material in this Project Pythia Cookbook is licensed for free and open consumption and reuse. All code is served under [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0), while all non-code content is licensed under [Creative Commons BY 4.0 (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/). Effectively, this means you are free to share and adapt this material so long as you give appropriate credit to the Cookbook authors and the Project Pythia community.
-
-The source code for the book is [released on GitHub](https://github.com/ProjectPythia/advanced-viz-cookbook) and archived on Zenodo. This DOI will always resolve to the latest release of the book source:
-
-[](https://zenodo.org/badge/latestdoi/671205314)
diff --git a/_preview/21/_sources/notebooks/mpas-datashader.ipynb b/_preview/21/_sources/notebooks/mpas-datashader.ipynb
deleted file mode 100644
index d0b4613..0000000
--- a/_preview/21/_sources/notebooks/mpas-datashader.ipynb
+++ /dev/null
@@ -1,452 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {
- "tags": []
- },
- "source": [
- "# MPAS with Datashader and Geoviews"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Overview\n",
- "\n",
- "This example of interactively plotting unstructured grid MPAS data with Datashader and Geoviews demonstrates making use of the MPAS file's connectivity information to render data on the native grid, and also\n",
- "avoid costly Delaunay triangulation that is required if the MPAS connectivity information is not used, rendering data that is sampled on both the 'primal' and 'dual' MPAS mesh, using geoviews/holoviews for interactive plotting in a Jupyter Notebook. The plotting is interactive in the sense that you can pan and zoom the data. Doing so will reveal greater and greater data fidelity, and sing Datashader to perform background rendering in place of Matplotlib. Unlike Matplotlib, Datashaderwas designed for performance with large data sets.\n",
- "\n",
- "1. Utility Functions\n",
- "2. Loading Data\n",
- "3. Using MPAS's cell connectivity array to plot primal mesh data\n",
- "4. Synthesizing triangles from points using Delaunay triangulation\n",
- "5. Using MPAS's cell connectivity array to plot dual mesh data"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Prerequisites\n",
- "\n",
- "| Concepts | Importance | Notes |\n",
- "| --- | --- | --- |\n",
- "| []() | Necessary | |\n",
- "\n",
- "- **Time to learn**: X minutes"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "---"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "import cartopy.crs as ccrs\n",
- "import numpy as np\n",
- "import pandas as pd\n",
- "\n",
- "import math as math\n",
- "\n",
- "import geocat.datafiles as gdf # Only for reading-in datasets\n",
- "\n",
- "from xarray import open_mfdataset\n",
- "\n",
- "from numba import jit\n",
- "\n",
- "import dask.dataframe as dd\n",
- "\n",
- "import holoviews as hv\n",
- "from holoviews import opts\n",
- "\n",
- "from holoviews.operation.datashader import rasterize as hds_rasterize \n",
- "#import geoviews.feature as gf # only needed for coastlines\n",
- "\n",
- "hv.extension(\"bokeh\",\"matplotlib\")\n",
- "\n",
- "opts.defaults(\n",
- " opts.Image(frame_width=600, data_aspect=1),\n",
- " opts.RGB(frame_width=600, data_aspect=1))"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Utility functions\n"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "# This funtion splits a global mesh along longitude\n",
- "#\n",
- "# Examine the X coordinates of each triangle in 'tris'. Return an array of 'tris' where only those triangles\n",
- "# with legs whose length is less than 't' are returned. \n",
- "# \n",
- "def unzipMesh(x,tris,t):\n",
- " return tris[(np.abs((x[tris[:,0]])-(x[tris[:,1]])) < t) & (np.abs((x[tris[:,0]])-(x[tris[:,2]])) < t)]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "# Compute the signed area of a triangle\n",
- "#\n",
- "def triArea(x,y,tris):\n",
- " return ((x[tris[:,1]]-x[tris[:,0]]) * (y[tris[:,2]]-y[tris[:,0]])) - ((x[tris[:,2]]-x[tris[:,0]]) * (y[tris[:,1]]-y[tris[:,0]]))"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "# Reorder triangles as necessary so they all have counter clockwise winding order. CCW is what Datashader and MPL\n",
- "# require.\n",
- "#\n",
- "def orderCCW(x,y,tris):\n",
- " tris[triArea(x,y,tris)<0.0,:] = tris[triArea(x,y,tris)<0.0,::-1]\n",
- " return(tris)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "# Create a Holoviews Triangle Mesh suitable for rendering with Datashader\n",
- "#\n",
- "# This function returns a Holoviews TriMesh that is created from a list of coordinates, 'x' and 'y',\n",
- "# an array of triangle indices that addressess the coordinates in 'x' and 'y', and a data variable 'var'. The\n",
- "# data variable's values will annotate the triangle vertices\n",
- "#\n",
- "\n",
- "def createHVTriMesh(x,y,triangle_indices, var,n_workers=1):\n",
- " # Declare verts array\n",
- " verts = np.column_stack([x, y, var])\n",
- "\n",
- "\n",
- " # Convert to pandas\n",
- " verts_df = pd.DataFrame(verts, columns=['x', 'y', 'z'])\n",
- " tris_df = pd.DataFrame(triangle_indices, columns=['v0', 'v1', 'v2'])\n",
- "\n",
- " # Convert to dask\n",
- " verts_ddf = dd.from_pandas(verts_df, npartitions=n_workers)\n",
- " tris_ddf = dd.from_pandas(tris_df, npartitions=n_workers)\n",
- "\n",
- " # Declare HoloViews element\n",
- " tri_nodes = hv.Nodes(verts_ddf, ['x', 'y', 'index'], ['z'])\n",
- " trimesh = hv.TriMesh((tris_ddf, tri_nodes))\n",
- " return(trimesh)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {
- "tags": []
- },
- "outputs": [],
- "source": [
- "# Triangulate MPAS primary mesh:\n",
- "#\n",
- "# Triangulate each polygon in a heterogenous mesh of n-gons by connecting\n",
- "# each internal polygon vertex to the first vertex. Uses the MPAS\n",
- "# auxilliary variables verticesOnCell, and nEdgesOnCell.\n",
- "#\n",
- "# The function is decorated with Numba's just-in-time compiler so that it is translated into\n",
- "# optimized machine code for better peformance\n",
- "#\n",
- "\n",
- "@jit(nopython=True)\n",
- "def triangulatePoly(verticesOnCell, nEdgesOnCell):\n",
- "\n",
- " # Calculate the number of triangles. nEdgesOnCell gives the number of vertices for each cell (polygon)\n",
- " # The number of triangles per polygon is the number of vertices minus 2.\n",
- " #\n",
- " nTriangles = np.sum(nEdgesOnCell - 2)\n",
- "\n",
- " triangles = np.ones((nTriangles, 3), dtype=np.int64)\n",
- " nCells = verticesOnCell.shape[0]\n",
- " triIndex = 0\n",
- " for j in range(nCells):\n",
- " for i in range(nEdgesOnCell[j]-2):\n",
- " triangles[triIndex][0] = verticesOnCell[j][0]\n",
- " triangles[triIndex][1] = verticesOnCell[j][i+1]\n",
- " triangles[triIndex][2] = verticesOnCell[j][i+2]\n",
- " triIndex += 1\n",
- "\n",
- " return triangles"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Load data and coordinates\n",
- "\n",
- "The global data sets used in this example are from the same experiment, but run at several resolutions from\n",
- "30km to 3.75km. Due to their size, the higher resolution data sets are only distributed with two variables\n",
- "in them:\n",
- "+ relhum_200hPa: Relative humidity vertically interpolated to 200 hPa\n",
- "+ vorticity_200hPa: Relative vorticity vertically interpolated to 200 hPa\n",
- "\n",
- "The dyamond_1 data set is available in several resolutions, ranging from 30 km to 3.75 km.\n",
- "\n",
- "Currently, the 30-km resolution dataset used in this example is available at geocat-datafiles.\n",
- "However, the other resolutions of these data are stored on Glade because of their size.\n",
- "\n",
- "The relhum_200hPa is computed on the MPAS 'primal' mesh, while the vorticity_200hPa is computed on the MPAS\n",
- "'dual' mesh. Note that data may also be sampled on the edges of the primal mesh. This example does not\n",
- "include/cover edge-centered data.\n",
- "\n",
- "These data are courtesy of NCAR's Falko Judt, and were produced as part of the DYAMOND initiative: \n",
- " http://dx.doi.org/10.1186/s40645-019-0304-z.\n"
- ]
- },
- {
- "cell_type": "raw",
- "metadata": {
- "tags": []
- },
- "source": [
- "# Load data\n",
- "\n",
- "datafiles = (gdf.get(\"netcdf_files/MPAS/FalkoJudt/dyamond_1/30km/diag.2016-08-20_00.00.00_subset.nc\"),\n",
- " gdf.get(\"netcdf_files/MPAS/FalkoJudt/dyamond_1/30km/x1.655362.grid_subset.nc\") )\n",
- "\n",
- "primalVarName = 'relhum_200hPa'\n",
- "dualVarName = 'vorticity_200hPa'\n",
- "central_longitude = 0.0\n",
- "\n",
- "ds = open_mfdataset(datafiles, decode_times=False)\n",
- "primalVar = ds[primalVarName].isel(Time=0).values\n",
- "dualVar = ds[dualVarName].isel(Time=0).values\n",
- "\n",
- "# Fetch lat and lon coordinates for the primal and dual mesh.\n",
- "lonCell = ds['lonCell'].values * 180.0 / math.pi\n",
- "latCell = ds['latCell'].values * 180.0 / math.pi\n",
- "lonCell = ((lonCell - 180.0) % 360.0) - 180.0\n",
- "\n",
- "lonVertex = ds['lonVertex'].values * 180.0 / math.pi\n",
- "latVertex = ds['latVertex'].values * 180.0 / math.pi\n",
- "lonVertex = ((lonVertex - 180.0) % 360.0) - 180.0"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {
- "tags": []
- },
- "source": [
- "## Using MPAS's cell connectivity array to plot primal mesh data\n",
- "\n",
- "In this example we use the MPAS `cellsOnVertex` auxilliary variable, which defines mesh connectivity for the MPAS grid.\n",
- "Specifically, this variable tells us the cell IDs for each cell that contains each vertex.\n",
- "\n",
- "The benefits of this are twofold: 1. We're using the actual mesh description from the MPAS output file; and 2. \n",
- "For large grid this is *much* faster than synthesizing the connectivity information as is done\n",
- "in the next example\n"
- ]
- },
- {
- "cell_type": "raw",
- "metadata": {
- "tags": []
- },
- "source": [
- "# Get triangle indices for each vertex in the MPAS file. Note, indexing in MPAS starts from 1, not zero :-(\n",
- "#\n",
- "tris = ds.cellsOnVertex.values - 1\n",
- "\n",
- "# The MPAS connectivity array unforunately does not seem to guarantee consistent clockwise winding order, which\n",
- "# is required by Datashader (and Matplotlib)\n",
- "#\n",
- "tris = orderCCW(lonCell,latCell,tris)\n",
- "\n",
- "# Lastly, we need to \"unzip\" the mesh along a constant line of longitude so that when we project to PCS coordinates\n",
- "# cells don't wrap around from east to west. The function below does the job, but it assumes that the \n",
- "# central_longitude from the map projection is 0.0. I.e. it will cut the mesh where longitude \n",
- "# wraps around from -180.0 to 180.0. We'll need to generalize this\n",
- "#\n",
- "tris = unzipMesh(lonCell,tris,90.0)\n",
- "\n",
- "\n",
- "# Project verts from geographic to PCS coordinates\n",
- "#\n",
- "projection = ccrs.Robinson(central_longitude=central_longitude)\n",
- "xPCS, yPCS, _ = projection.transform_points(ccrs.PlateCarree(), lonCell, latCell).T\n",
- "\n",
- "\n",
- "trimesh = createHVTriMesh(xPCS,yPCS,tris, primalVar,n_workers=n_workers)"
- ]
- },
- {
- "cell_type": "raw",
- "metadata": {
- "tags": []
- },
- "source": [
- "# Use precompute so it caches the data internally\n",
- "rasterized = hds_rasterize(trimesh, aggregator='mean', precompute=True)\n",
- "rasterized.opts(tools=['hover'], colorbar=True, cmap='coolwarm') * gf.coastline(projection=projection)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Synthesizing triangles from points using Delaunay triangulation\n",
- "\n",
- "In this second example we do not use the triangle connectivity information stored in the MPAS file. Instead we\n",
- "use Delaunay triangulation to artifically create a triangle mesh. The benefit of this approach is that we do not\n",
- "need the MPAS cellsOnVertex variable if it is not available. Also, since the triangulation algorithm is run on the \n",
- "coordinates after they are projected to meters we do not have to worry about wraparound. The downside is that for\n",
- "high-resolution data Delaunay triangulation is prohibitively expensive. The highest resolution data set included\n",
- "in this notebook (3.75km) will not triangulate in a reasonable amount of time, if at all \n"
- ]
- },
- {
- "cell_type": "raw",
- "metadata": {},
- "source": [
- "# Use Delaunay triangulation to generate the triangle connectivity. Note, it's important that the coordinate \n",
- "# arrays already be in PCS coordinates (not lat-lon) for the triangulation to perform optimally\n",
- "#\n",
- "\n",
- "from matplotlib.tri import Triangulation\n",
- "\n",
- "tris = Triangulation(xPCS,yPCS).triangles\n",
- "\n",
- "trimesh = createHVTriMesh(xPCS,yPCS,tris, primalVar,n_workers=n_workers)"
- ]
- },
- {
- "cell_type": "raw",
- "metadata": {},
- "source": [
- "# Use precompute so it caches the data internally\n",
- "rasterized = hds_rasterize(trimesh, aggregator='mean', precompute=True)\n",
- "rasterized.opts(tools=['hover'], colorbar=True, cmap='coolwarm') * gf.coastline(projection=projection)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Using MPAS's cell connectivity array to plot dual mesh data\n",
- "\n",
- "In this example we use the MPAS `verticesOnCell` and `nEdgesOnCell` auxilliary variables, which defines mesh connectivity for the\n",
- "MPAS dual grid.\n",
- "\n",
- "As with the first example using the MPAS primal grid, data on the dual grid could be plotted by first\n",
- "triangulating them with, for example, Delaunay triangulation. But using grid's native connectivity information \n",
- "is faster.\n"
- ]
- },
- {
- "cell_type": "raw",
- "metadata": {},
- "source": [
- "verticesOnCell = ds.verticesOnCell.values - 1\n",
- "nEdgesOnCell = ds.nEdgesOnCell.values\n",
- "\n",
- "# For the dual mesh the data are located on triangle centers, which correspond to cell (polygon) vertices. Here\n",
- "# we decompose each cell into triangles\n",
- "#\n",
- "tris = triangulatePoly(verticesOnCell, nEdgesOnCell)\n",
- "\n",
- "tris = unzipMesh(lonVertex,tris,90.0)\n",
- "\n",
- "# Project verts from geographic to PCS coordinates\n",
- "#\n",
- "projection = ccrs.Robinson(central_longitude=central_longitude)\n",
- "xPCS, yPCS, _ = projection.transform_points(ccrs.PlateCarree(), lonVertex, latVertex).T\n",
- "\n",
- "trimesh = createHVTriMesh(xPCS,yPCS,tris, dualVar,n_workers=n_workers)"
- ]
- },
- {
- "cell_type": "raw",
- "metadata": {},
- "source": [
- "rasterized = hds_rasterize(trimesh, aggregator='mean', precompute=True)\n",
- "rasterized.opts(tools=['hover'], colorbar=True, cmap='coolwarm') * gf.coastline(projection=projection)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Summary\n",
- "\n",
- "### What's next?\n"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Resources and references\n",
- "\n",
- "- []()"
- ]
- }
- ],
- "metadata": {
- "kernelspec": {
- "display_name": "Python 3 (ipykernel)",
- "language": "python",
- "name": "python3"
- },
- "language_info": {
- "codemirror_mode": {
- "name": "ipython",
- "version": 3
- },
- "file_extension": ".py",
- "mimetype": "text/x-python",
- "name": "python",
- "nbconvert_exporter": "python",
- "pygments_lexer": "ipython3",
- "version": "3.10.12"
- },
- "widgets": {
- "application/vnd.jupyter.widget-state+json": {
- "state": {},
- "version_major": 2,
- "version_minor": 0
- }
- }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/_preview/21/_sources/notebooks/notebook-template.ipynb b/_preview/21/_sources/notebooks/notebook-template.ipynb
deleted file mode 100644
index dad9f26..0000000
--- a/_preview/21/_sources/notebooks/notebook-template.ipynb
+++ /dev/null
@@ -1,358 +0,0 @@
-{
- "cells": [
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Let's start here! If you can directly link to an image relevant to your notebook, such as [canonical logos](https://github.com/numpy/numpy/blob/main/doc/source/_static/numpylogo.svg), do so here at the top of your notebook. You can do this with Markdown syntax,\n",
- "\n",
- "> `![![\"Project](\"images/ProjectPythia_Logo_Final-01-Blue.svg\"){kind=logo}
"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "# Project Pythia Notebook Template\n",
- "\n",
- "Next, title your notebook appropriately with a top-level Markdown header, `#`. Do not use this level header anywhere else in the notebook. Our book build process will use this title in the navbar, table of contents, etc. Keep it short, keep it descriptive. Follow this with a `---` cell to visually distinguish the transition to the prerequisites section."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Overview\n",
- "If you have an introductory paragraph, lead with it here! Keep it short and tied to your material, then be sure to continue into the required list of topics below,\n",
- "\n",
- "1. This is a numbered list of the specific topics\n",
- "1. These should map approximately to your main sections of content\n",
- "1. Or each second-level, `##`, header in your notebook\n",
- "1. Keep the size and scope of your notebook in check\n",
- "1. And be sure to let the reader know up front the important concepts they'll be leaving with"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Prerequisites\n",
- "This section was inspired by [this template](https://github.com/alan-turing-institute/the-turing-way/blob/master/book/templates/chapter-template/chapter-landing-page.md) of the wonderful [The Turing Way](https://the-turing-way.netlify.app) Jupyter Book.\n",
- "\n",
- "Following your overview, tell your reader what concepts, packages, or other background information they'll **need** before learning your material. Tie this explicitly with links to other pages here in Foundations or to relevant external resources. Remove this body text, then populate the Markdown table, denoted in this cell with `|` vertical brackets, below, and fill out the information following. In this table, lay out prerequisite concepts by explicitly linking to other Foundations material or external resources, or describe generally helpful concepts.\n",
- "\n",
- "Label the importance of each concept explicitly as **helpful/necessary**.\n",
- "\n",
- "| Concepts | Importance | Notes |\n",
- "| --- | --- | --- |\n",
- "| [Intro to Cartopy](https://foundations.projectpythia.org/core/cartopy/cartopy.html) | Necessary | |\n",
- "| [Understanding of NetCDF](https://foundations.projectpythia.org/core/data-formats/netcdf-cf.html) | Helpful | Familiarity with metadata structure |\n",
- "| Project management | Helpful | |\n",
- "\n",
- "- **Time to learn**: estimate in minutes. For a rough idea, use 5 mins per subsection, 10 if longer; add these up for a total. Safer to round up and overestimate.\n",
- "- **System requirements**:\n",
- " - Populate with any system, version, or non-Python software requirements if necessary\n",
- " - Otherwise use the concepts table above and the Imports section below to describe required packages as necessary\n",
- " - If no extra requirements, remove the **System requirements** point altogether"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "---"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Imports\n",
- "Begin your body of content with another `---` divider before continuing into this section, then remove this body text and populate the following code cell with all necessary Python imports **up-front**:"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "import sys"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Your first content section"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "This is where you begin your first section of material, loosely tied to your objectives stated up front. Tie together your notebook as a narrative, with interspersed Markdown text, images, and more as necessary,"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# as well as any and all of your code cells\n",
- "print(\"Hello world!\")"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### A content subsection\n",
- "Divide and conquer your objectives with Markdown subsections, which will populate the helpful navbar in Jupyter Lab and here on the Jupyter Book!"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
- "source": [
- "# some subsection code\n",
- "new = \"helpful information\""
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Another content subsection\n",
- "Keep up the good work! A note, *try to avoid using code comments as narrative*, and instead let them only exist as brief clarifications where necessary."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Your second content section\n",
- "Here we can move on to our second objective, and we can demonstrate"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Subsection to the second section\n",
- "\n",
- "#### a quick demonstration\n",
- "\n",
- "##### of further and further\n",
- "\n",
- "###### header levels"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "as well $m = a * t / h$ text! Similarly, you have access to other $\\LaTeX$ equation [**functionality**](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Typesetting%20Equations.html) via MathJax (demo below from link),\n",
- "\n",
- "\\begin{align}\n",
- "\\dot{x} & = \\sigma(y-x) \\\\\n",
- "\\dot{y} & = \\rho x - y - xz \\\\\n",
- "\\dot{z} & = -\\beta z + xy\n",
- "\\end{align}"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "Check out [**any number of helpful Markdown resources**](https://www.markdownguide.org/basic-syntax/) for further customizing your notebooks and the [**Jupyter docs**](https://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Working%20With%20Markdown%20Cells.html) for Jupyter-specific formatting information. Don't hesitate to ask questions if you have problems getting it to look *just right*."
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "## Last Section\n",
- "\n",
- "If you're comfortable, and as we briefly used for our embedded logo up top, you can embed raw html into Jupyter Markdown cells (edit to see):"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "