From ee2e85407a86fcc546ec3ffac3ed9dfdf13d947a Mon Sep 17 00:00:00 2001 From: Justin Richling <36716747+MethaneRain@users.noreply.github.com> Date: Fri, 15 Nov 2019 11:41:59 -0700 Subject: [PATCH 1/5] Add files via upload --- HiLo.py | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 HiLo.py diff --git a/HiLo.py b/HiLo.py new file mode 100644 index 00000000000..ff940181460 --- /dev/null +++ b/HiLo.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python +# coding: utf-8 + + + +def plot_maxmin_points(ax,lon, lat, data, extrema, nsize, symbol,color='k', outline_color='k', + outline_width=2.5, press_spacing=0.66,plotValue=True, transform=None): + + """ + ax argument allows for sending current axis to the HiLo plot + + Path effects on the symbols and pressure readings - outline them in black (default) with linewidth + 2.5 (default) to make them pop a bit more. The press_spacing (0.66 default) is based off latitude and helps + serarate the pressure reading and the symbol with the outline effects making them overlap. + + + This function will find and plot relative maximum and minimum for a 2D grid. The function + can be used to plot an H for maximum values (e.g., High pressure) and an L for minimum + values (e.g., low pressue). It is best to used filetered data to obtain a synoptic scale + max/min value. The symbol text can be set to a string value and optionally the color of the + symbol and any plotted value can be set with the parameter color + lon = plotting longitude values (2D) + lat = plotting latitude values (2D) + data = 2D data that you wish to plot the max/min symbol placement + extrema = Either a value of max for Maximum Values or min for Minimum Values + nsize = Size of the grid box to filter the max and min values to plot a reasonable number + symbol = String to be placed at location of max/min value + color = String matplotlib colorname to plot the symbol (and numerica value, if plotted) + plot_value = Boolean (True/False) of whether to plot the numeric value of max/min point + The max/min symbol will be plotted on the current axes within the bounding frame + (e.g., clip_on=True) + """ + import numpy as np + from matplotlib import patheffects + from scipy.ndimage.filters import maximum_filter, minimum_filter + outline_effect = [patheffects.withStroke(linewidth=outline_width, foreground=outline_color)] + + if (extrema == 'max'): + data_ext = maximum_filter(data, nsize, mode='nearest') + elif (extrema == 'min'): + data_ext = minimum_filter(data, nsize, mode='nearest') + else: + raise ValueError('Value for hilo must be either max or min') + + mxy, mxx = np.where(data_ext == data) + #print(mxy,mxx) + + for i in range(len(mxy)): + A = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]], symbol, color=color, size=24, + clip_on=True, horizontalalignment='center', verticalalignment='center', + transform=transform) + A.set_path_effects(outline_effect) + B = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]]-float(press_spacing), + str(np.int(data[mxy[i], mxx[i]])), + color=color, size=12, clip_on=True, fontweight='bold', + horizontalalignment='center', verticalalignment='top', transform=transform) + B.set_path_effects(outline_effect) + + From 755c13fb5b240df0099bc78dc0bae76e1a67677f Mon Sep 17 00:00:00 2001 From: JustinR Date: Sun, 17 Nov 2019 13:33:45 -0700 Subject: [PATCH 2/5] Update HiLo Thickness Example Made HiLo module for importing plot_maxmin_points function Added ax call and text outline with format options --- examples/HILO_Symbol_Plot.ipynb | 290 ++++++++++++++++++++++++++++++++ examples/HiLo.py | 59 +++++++ 2 files changed, 349 insertions(+) create mode 100644 examples/HILO_Symbol_Plot.ipynb create mode 100644 examples/HiLo.py diff --git a/examples/HILO_Symbol_Plot.ipynb b/examples/HILO_Symbol_Plot.ipynb new file mode 100644 index 00000000000..92800f3cbe4 --- /dev/null +++ b/examples/HILO_Symbol_Plot.ipynb @@ -0,0 +1,290 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# MSLP and 1000-500 hPa Thickness with High and Low Symbols\n", + "\n", + "\n", + "Plot MSLP, calculate and plot 1000-500 hPa thickness, and plot H and L markers.\n", + "Beyond just plotting a few variables, in the example we use functionality\n", + "from the scipy module to find local maximum and minimimum values within the\n", + "MSLP field in order to plot symbols at those locations.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Imports\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime\n", + "\n", + "import cartopy.crs as ccrs\n", + "import cartopy.feature as cfeature\n", + "import matplotlib.pyplot as plt\n", + "from metpy.units import units\n", + "from netCDF4 import num2date\n", + "import numpy as np\n", + "from scipy.ndimage import gaussian_filter\n", + "from siphon.ncss import NCSS\n", + "\n", + "# Optional HiLo import for plot_maxmin_points module\n", + "from HiLo import plot_maxmin_points as plot_maxmin_points" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Function for finding and plotting max/min points\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_maxmin_points(ax, lon, lat, data, extrema, nsize, symbol,color='k', outline_color='k',\n", + " outline_width=2.5, press_spacing=0.66, plotValue=True, transform=None):\n", + "\n", + " \"\"\"\n", + " ax argument allows for sending current axis to the plot \n", + " \n", + " Path effects on the symbols and pressure readings - outline them in black (default) with linewidth \n", + " 2.5 (default) to make them pop a bit more. The press_spacing (0.66 default) is based off latitude and helps \n", + " serarate the pressure reading and the symbol with the outline effects making them overlap.\n", + " \n", + " \n", + " This function will find and plot relative maximum and minimum for a 2D grid. The function\n", + " can be used to plot an H for maximum values (e.g., High pressure) and an L for minimum\n", + " values (e.g., low pressue). It is best to used filetered data to obtain a synoptic scale\n", + " max/min value. The symbol text can be set to a string value and optionally the color of the\n", + " symbol and any plotted value can be set with the parameter color\n", + " lon = plotting longitude values (2D)\n", + " lat = plotting latitude values (2D)\n", + " data = 2D data that you wish to plot the max/min symbol placement\n", + " extrema = Either a value of max for Maximum Values or min for Minimum Values\n", + " nsize = Size of the grid box to filter the max and min values to plot a reasonable number\n", + " symbol = String to be placed at location of max/min value\n", + " color = String matplotlib colorname to plot the symbol (and numerica value, if plotted)\n", + " plot_value = Boolean (True/False) of whether to plot the numeric value of max/min point\n", + " The max/min symbol will be plotted on the current axes within the bounding frame\n", + " (e.g., clip_on=True)\n", + " \"\"\"\n", + " import numpy as np\n", + " from matplotlib import patheffects\n", + " from scipy.ndimage.filters import maximum_filter, minimum_filter\n", + " outline_effect = [patheffects.withStroke(linewidth=outline_width, foreground=outline_color)]\n", + "\n", + " if (extrema == 'max'):\n", + " data_ext = maximum_filter(data, nsize, mode='nearest')\n", + " elif (extrema == 'min'):\n", + " data_ext = minimum_filter(data, nsize, mode='nearest')\n", + " else:\n", + " raise ValueError('Value for hilo must be either max or min')\n", + " \n", + " mxy, mxx = np.where(data_ext == data)\n", + " #print(mxy,mxx)\n", + " \n", + " for i in range(len(mxy)):\n", + " symb_text = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]], symbol, color=color, size=24,\n", + " clip_on=True, horizontalalignment='center', verticalalignment='center',\n", + " transform=transform)\n", + " symb_text.set_path_effects(outline_effect)\n", + " \n", + " press_text = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]]-float(press_spacing),\n", + " str(np.int(data[mxy[i], mxx[i]])),\n", + " color=color, size=12, clip_on=True, fontweight='bold',\n", + " horizontalalignment='center', verticalalignment='top', transform=transform)\n", + " press_text.set_path_effects(outline_effect)\n", + " \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get NARR data\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "dattim = datetime(1999, 1, 3, 0)\n", + "\n", + "ncss = NCSS('https://www.ncei.noaa.gov/thredds/ncss/grid/narr-a-files/{0:%Y%m}/{0:%Y%m%d}/'\n", + " 'narr-a_221_{0:%Y%m%d}_{0:%H}00_000.grb'.format(dattim))\n", + "query = ncss.query()\n", + "query.all_times().variables('Pressure_reduced_to_MSL_msl',\n", + " 'Geopotential_height_isobaric').add_lonlat().accept('netcdf')\n", + "data = ncss.get_data(query)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Extract data into variables\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Grab pressure levels\n", + "plev = list(data.variables['isobaric1'][:])\n", + "\n", + "# Grab lat/lons and make all lons 0-360\n", + "lats = data.variables['lat'][:]\n", + "lons = data.variables['lon'][:]\n", + "lons[lons < 0] = 360 + lons[lons < 0]\n", + "\n", + "# Grab valid time and get into datetime format\n", + "time = data['time2']\n", + "vtime = num2date(time[:], units=time.units)\n", + "\n", + "# Grab MSLP and smooth, use MetPy Units module for conversion\n", + "EMSL = data.variables['Pressure_reduced_to_MSL_msl'][:] * units.Pa\n", + "EMSL.ito('hPa')\n", + "mslp = gaussian_filter(EMSL[0], sigma=3.0)\n", + "\n", + "# Grab pressure level data\n", + "hght_1000 = data.variables['Geopotential_height_isobaric'][0, plev.index(1000)]\n", + "hght_500 = data.variables['Geopotential_height_isobaric'][0, plev.index(500)]\n", + "\n", + "# Calculate and smooth 1000-500 hPa thickness\n", + "thickness_1000_500 = gaussian_filter(hght_500 - hght_1000, sigma=3.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set map and data projections for use in mapping\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Set projection of map display\n", + "mapproj = ccrs.LambertConformal(central_latitude=45., central_longitude=-100.)\n", + "\n", + "# Set projection of data\n", + "dataproj = ccrs.PlateCarree()\n", + "\n", + "# Grab data for plotting state boundaries\n", + "states_provinces = cfeature.NaturalEarthFeature(\n", + " category='cultural',\n", + " name='admin_1_states_provinces_lakes',\n", + " scale='50m',\n", + " facecolor='none')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create figure and plot data\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig = plt.figure(1, figsize=(17., 11.))\n", + "ax = plt.subplot(111, projection=mapproj)\n", + "\n", + "# Set extent and plot map lines\n", + "ax.set_extent([-145., -70, 20., 60.], ccrs.PlateCarree())\n", + "ax.coastlines('50m', edgecolor='black', linewidth=0.75)\n", + "ax.add_feature(states_provinces, edgecolor='black', linewidth=0.5)\n", + "\n", + "# Plot thickness with multiple colors\n", + "clevs = (np.arange(0, 5400, 60),\n", + " np.array([5400]),\n", + " np.arange(5460, 7000, 60))\n", + "colors = ('tab:blue', 'b', 'tab:red')\n", + "kw_clabels = {'fontsize': 11, 'inline': True, 'inline_spacing': 5, 'fmt': '%i',\n", + " 'rightside_up': True, 'use_clabeltext': True}\n", + "for clevthick, color in zip(clevs, colors):\n", + " cs = ax.contour(lons, lats, thickness_1000_500, levels=clevthick, colors=color,\n", + " linewidths=1.0, linestyles='dashed', transform=dataproj)\n", + " plt.clabel(cs, **kw_clabels)\n", + "\n", + "# Plot MSLP\n", + "clevmslp = np.arange(800., 1120., 4)\n", + "cs2 = ax.contour(lons, lats, mslp, clevmslp, colors='k', linewidths=1.25,\n", + " linestyles='solid', transform=dataproj)\n", + "plt.clabel(cs2, **kw_clabels)\n", + "\n", + "# Use definition to plot H/L symbols\n", + "plot_maxmin_points(ax,lons, lats, mslp, 'max', 50, symbol='H', color='b', transform=dataproj)\n", + "plot_maxmin_points(ax,lons, lats, mslp, 'min', 25, symbol='L', color='r', transform=dataproj)\n", + "\n", + "# Put on some titles\n", + "plt.title('MSLP (hPa) with Highs and Lows, 1000-500 hPa Thickness (m)', loc='left')\n", + "plt.title('VALID: {}'.format(vtime[0]), loc='right')\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/examples/HiLo.py b/examples/HiLo.py new file mode 100644 index 00000000000..ff940181460 --- /dev/null +++ b/examples/HiLo.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python +# coding: utf-8 + + + +def plot_maxmin_points(ax,lon, lat, data, extrema, nsize, symbol,color='k', outline_color='k', + outline_width=2.5, press_spacing=0.66,plotValue=True, transform=None): + + """ + ax argument allows for sending current axis to the HiLo plot + + Path effects on the symbols and pressure readings - outline them in black (default) with linewidth + 2.5 (default) to make them pop a bit more. The press_spacing (0.66 default) is based off latitude and helps + serarate the pressure reading and the symbol with the outline effects making them overlap. + + + This function will find and plot relative maximum and minimum for a 2D grid. The function + can be used to plot an H for maximum values (e.g., High pressure) and an L for minimum + values (e.g., low pressue). It is best to used filetered data to obtain a synoptic scale + max/min value. The symbol text can be set to a string value and optionally the color of the + symbol and any plotted value can be set with the parameter color + lon = plotting longitude values (2D) + lat = plotting latitude values (2D) + data = 2D data that you wish to plot the max/min symbol placement + extrema = Either a value of max for Maximum Values or min for Minimum Values + nsize = Size of the grid box to filter the max and min values to plot a reasonable number + symbol = String to be placed at location of max/min value + color = String matplotlib colorname to plot the symbol (and numerica value, if plotted) + plot_value = Boolean (True/False) of whether to plot the numeric value of max/min point + The max/min symbol will be plotted on the current axes within the bounding frame + (e.g., clip_on=True) + """ + import numpy as np + from matplotlib import patheffects + from scipy.ndimage.filters import maximum_filter, minimum_filter + outline_effect = [patheffects.withStroke(linewidth=outline_width, foreground=outline_color)] + + if (extrema == 'max'): + data_ext = maximum_filter(data, nsize, mode='nearest') + elif (extrema == 'min'): + data_ext = minimum_filter(data, nsize, mode='nearest') + else: + raise ValueError('Value for hilo must be either max or min') + + mxy, mxx = np.where(data_ext == data) + #print(mxy,mxx) + + for i in range(len(mxy)): + A = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]], symbol, color=color, size=24, + clip_on=True, horizontalalignment='center', verticalalignment='center', + transform=transform) + A.set_path_effects(outline_effect) + B = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]]-float(press_spacing), + str(np.int(data[mxy[i], mxx[i]])), + color=color, size=12, clip_on=True, fontweight='bold', + horizontalalignment='center', verticalalignment='top', transform=transform) + B.set_path_effects(outline_effect) + + From 6375d1d3f43197210676d5bde0ca37829a2599c3 Mon Sep 17 00:00:00 2001 From: JustinR Date: Sun, 17 Nov 2019 13:34:57 -0700 Subject: [PATCH 3/5] Create HILO_Symbol_Plot.py --- examples/HILO_Symbol_Plot.py | 217 +++++++++++++++++++++++++++++++++++ 1 file changed, 217 insertions(+) create mode 100644 examples/HILO_Symbol_Plot.py diff --git a/examples/HILO_Symbol_Plot.py b/examples/HILO_Symbol_Plot.py new file mode 100644 index 00000000000..4132ff82f95 --- /dev/null +++ b/examples/HILO_Symbol_Plot.py @@ -0,0 +1,217 @@ +#!/usr/bin/env python +# coding: utf-8 + +# In[ ]: + + +get_ipython().run_line_magic('matplotlib', 'inline') + + +# +# # MSLP and 1000-500 hPa Thickness with High and Low Symbols +# +# +# Plot MSLP, calculate and plot 1000-500 hPa thickness, and plot H and L markers. +# Beyond just plotting a few variables, in the example we use functionality +# from the scipy module to find local maximum and minimimum values within the +# MSLP field in order to plot symbols at those locations. +# + +# Imports +# +# + +# In[ ]: + + +from datetime import datetime + +import cartopy.crs as ccrs +import cartopy.feature as cfeature +import matplotlib.pyplot as plt +from metpy.units import units +from netCDF4 import num2date +import numpy as np +from scipy.ndimage import gaussian_filter +from siphon.ncss import NCSS + +# Optional HiLo import for plot_maxmin_points module +from HiLo import plot_maxmin_points as plot_maxmin_points + + +# Function for finding and plotting max/min points +# +# + +# In[ ]: + + +def plot_maxmin_points(ax, lon, lat, data, extrema, nsize, symbol,color='k', outline_color='k', + outline_width=2.5, press_spacing=0.66, plotValue=True, transform=None): + + """ + ax argument allows for sending current axis to the plot + + Path effects on the symbols and pressure readings - outline them in black (default) with linewidth + 2.5 (default) to make them pop a bit more. The press_spacing (0.66 default) is based off latitude and helps + serarate the pressure reading and the symbol with the outline effects making them overlap. + + + This function will find and plot relative maximum and minimum for a 2D grid. The function + can be used to plot an H for maximum values (e.g., High pressure) and an L for minimum + values (e.g., low pressue). It is best to used filetered data to obtain a synoptic scale + max/min value. The symbol text can be set to a string value and optionally the color of the + symbol and any plotted value can be set with the parameter color + lon = plotting longitude values (2D) + lat = plotting latitude values (2D) + data = 2D data that you wish to plot the max/min symbol placement + extrema = Either a value of max for Maximum Values or min for Minimum Values + nsize = Size of the grid box to filter the max and min values to plot a reasonable number + symbol = String to be placed at location of max/min value + color = String matplotlib colorname to plot the symbol (and numerica value, if plotted) + plot_value = Boolean (True/False) of whether to plot the numeric value of max/min point + The max/min symbol will be plotted on the current axes within the bounding frame + (e.g., clip_on=True) + """ + import numpy as np + from matplotlib import patheffects + from scipy.ndimage.filters import maximum_filter, minimum_filter + outline_effect = [patheffects.withStroke(linewidth=outline_width, foreground=outline_color)] + + if (extrema == 'max'): + data_ext = maximum_filter(data, nsize, mode='nearest') + elif (extrema == 'min'): + data_ext = minimum_filter(data, nsize, mode='nearest') + else: + raise ValueError('Value for hilo must be either max or min') + + mxy, mxx = np.where(data_ext == data) + #print(mxy,mxx) + + for i in range(len(mxy)): + symb_text = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]], symbol, color=color, size=24, + clip_on=True, horizontalalignment='center', verticalalignment='center', + transform=transform) + symb_text.set_path_effects(outline_effect) + + press_text = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]]-float(press_spacing), + str(np.int(data[mxy[i], mxx[i]])), + color=color, size=12, clip_on=True, fontweight='bold', + horizontalalignment='center', verticalalignment='top', transform=transform) + press_text.set_path_effects(outline_effect) + + + +# Get NARR data +# +# + +# In[ ]: + + +dattim = datetime(1999, 1, 3, 0) + +ncss = NCSS('https://www.ncei.noaa.gov/thredds/ncss/grid/narr-a-files/{0:%Y%m}/{0:%Y%m%d}/' + 'narr-a_221_{0:%Y%m%d}_{0:%H}00_000.grb'.format(dattim)) +query = ncss.query() +query.all_times().variables('Pressure_reduced_to_MSL_msl', + 'Geopotential_height_isobaric').add_lonlat().accept('netcdf') +data = ncss.get_data(query) + + +# Extract data into variables +# +# + +# In[ ]: + + +# Grab pressure levels +plev = list(data.variables['isobaric1'][:]) + +# Grab lat/lons and make all lons 0-360 +lats = data.variables['lat'][:] +lons = data.variables['lon'][:] +lons[lons < 0] = 360 + lons[lons < 0] + +# Grab valid time and get into datetime format +time = data['time2'] +vtime = num2date(time[:], units=time.units) + +# Grab MSLP and smooth, use MetPy Units module for conversion +EMSL = data.variables['Pressure_reduced_to_MSL_msl'][:] * units.Pa +EMSL.ito('hPa') +mslp = gaussian_filter(EMSL[0], sigma=3.0) + +# Grab pressure level data +hght_1000 = data.variables['Geopotential_height_isobaric'][0, plev.index(1000)] +hght_500 = data.variables['Geopotential_height_isobaric'][0, plev.index(500)] + +# Calculate and smooth 1000-500 hPa thickness +thickness_1000_500 = gaussian_filter(hght_500 - hght_1000, sigma=3.0) + + +# Set map and data projections for use in mapping +# +# + +# In[ ]: + + +# Set projection of map display +mapproj = ccrs.LambertConformal(central_latitude=45., central_longitude=-100.) + +# Set projection of data +dataproj = ccrs.PlateCarree() + +# Grab data for plotting state boundaries +states_provinces = cfeature.NaturalEarthFeature( + category='cultural', + name='admin_1_states_provinces_lakes', + scale='50m', + facecolor='none') + + +# Create figure and plot data +# +# + +# In[ ]: + + +fig = plt.figure(1, figsize=(17., 11.)) +ax = plt.subplot(111, projection=mapproj) + +# Set extent and plot map lines +ax.set_extent([-145., -70, 20., 60.], ccrs.PlateCarree()) +ax.coastlines('50m', edgecolor='black', linewidth=0.75) +ax.add_feature(states_provinces, edgecolor='black', linewidth=0.5) + +# Plot thickness with multiple colors +clevs = (np.arange(0, 5400, 60), + np.array([5400]), + np.arange(5460, 7000, 60)) +colors = ('tab:blue', 'b', 'tab:red') +kw_clabels = {'fontsize': 11, 'inline': True, 'inline_spacing': 5, 'fmt': '%i', + 'rightside_up': True, 'use_clabeltext': True} +for clevthick, color in zip(clevs, colors): + cs = ax.contour(lons, lats, thickness_1000_500, levels=clevthick, colors=color, + linewidths=1.0, linestyles='dashed', transform=dataproj) + plt.clabel(cs, **kw_clabels) + +# Plot MSLP +clevmslp = np.arange(800., 1120., 4) +cs2 = ax.contour(lons, lats, mslp, clevmslp, colors='k', linewidths=1.25, + linestyles='solid', transform=dataproj) +plt.clabel(cs2, **kw_clabels) + +# Use definition to plot H/L symbols +plot_maxmin_points(ax,lons, lats, mslp, 'max', 50, symbol='H', color='b', transform=dataproj) +plot_maxmin_points(ax,lons, lats, mslp, 'min', 25, symbol='L', color='r', transform=dataproj) + +# Put on some titles +plt.title('MSLP (hPa) with Highs and Lows, 1000-500 hPa Thickness (m)', loc='left') +plt.title('VALID: {}'.format(vtime[0]), loc='right') + +plt.show() + From 8c8c592d440d3eb8edfbb50769a8947e2374e504 Mon Sep 17 00:00:00 2001 From: JustinR Date: Sun, 17 Nov 2019 13:41:07 -0700 Subject: [PATCH 4/5] Updated HILO_Symbol Removed local function of plot_maxmin_points Used import of HILO module to get plot_maxmin_points --- examples/HILO_Symbol_Plot.ipynb | 94 ++++++++------------------ examples/HILO_Symbol_Plot.py | 116 ++------------------------------ 2 files changed, 35 insertions(+), 175 deletions(-) diff --git a/examples/HILO_Symbol_Plot.ipynb b/examples/HILO_Symbol_Plot.ipynb index 92800f3cbe4..a2c905a44c6 100644 --- a/examples/HILO_Symbol_Plot.ipynb +++ b/examples/HILO_Symbol_Plot.ipynb @@ -33,7 +33,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -46,10 +46,7 @@ "from netCDF4 import num2date\n", "import numpy as np\n", "from scipy.ndimage import gaussian_filter\n", - "from siphon.ncss import NCSS\n", - "\n", - "# Optional HiLo import for plot_maxmin_points module\n", - "from HiLo import plot_maxmin_points as plot_maxmin_points" + "from siphon.ncss import NCSS" ] }, { @@ -66,61 +63,8 @@ "metadata": {}, "outputs": [], "source": [ - "def plot_maxmin_points(ax, lon, lat, data, extrema, nsize, symbol,color='k', outline_color='k',\n", - " outline_width=2.5, press_spacing=0.66, plotValue=True, transform=None):\n", - "\n", - " \"\"\"\n", - " ax argument allows for sending current axis to the plot \n", - " \n", - " Path effects on the symbols and pressure readings - outline them in black (default) with linewidth \n", - " 2.5 (default) to make them pop a bit more. The press_spacing (0.66 default) is based off latitude and helps \n", - " serarate the pressure reading and the symbol with the outline effects making them overlap.\n", - " \n", - " \n", - " This function will find and plot relative maximum and minimum for a 2D grid. The function\n", - " can be used to plot an H for maximum values (e.g., High pressure) and an L for minimum\n", - " values (e.g., low pressue). It is best to used filetered data to obtain a synoptic scale\n", - " max/min value. The symbol text can be set to a string value and optionally the color of the\n", - " symbol and any plotted value can be set with the parameter color\n", - " lon = plotting longitude values (2D)\n", - " lat = plotting latitude values (2D)\n", - " data = 2D data that you wish to plot the max/min symbol placement\n", - " extrema = Either a value of max for Maximum Values or min for Minimum Values\n", - " nsize = Size of the grid box to filter the max and min values to plot a reasonable number\n", - " symbol = String to be placed at location of max/min value\n", - " color = String matplotlib colorname to plot the symbol (and numerica value, if plotted)\n", - " plot_value = Boolean (True/False) of whether to plot the numeric value of max/min point\n", - " The max/min symbol will be plotted on the current axes within the bounding frame\n", - " (e.g., clip_on=True)\n", - " \"\"\"\n", - " import numpy as np\n", - " from matplotlib import patheffects\n", - " from scipy.ndimage.filters import maximum_filter, minimum_filter\n", - " outline_effect = [patheffects.withStroke(linewidth=outline_width, foreground=outline_color)]\n", - "\n", - " if (extrema == 'max'):\n", - " data_ext = maximum_filter(data, nsize, mode='nearest')\n", - " elif (extrema == 'min'):\n", - " data_ext = minimum_filter(data, nsize, mode='nearest')\n", - " else:\n", - " raise ValueError('Value for hilo must be either max or min')\n", - " \n", - " mxy, mxx = np.where(data_ext == data)\n", - " #print(mxy,mxx)\n", - " \n", - " for i in range(len(mxy)):\n", - " symb_text = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]], symbol, color=color, size=24,\n", - " clip_on=True, horizontalalignment='center', verticalalignment='center',\n", - " transform=transform)\n", - " symb_text.set_path_effects(outline_effect)\n", - " \n", - " press_text = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]]-float(press_spacing),\n", - " str(np.int(data[mxy[i], mxx[i]])),\n", - " color=color, size=12, clip_on=True, fontweight='bold',\n", - " horizontalalignment='center', verticalalignment='top', transform=transform)\n", - " press_text.set_path_effects(outline_effect)\n", - " \n", - "\n" + "# import HiLo module for plot_maxmin_points function\n", + "from HiLo import plot_maxmin_points as plot_maxmin_points" ] }, { @@ -133,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -157,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -196,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -224,9 +168,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "fig = plt.figure(1, figsize=(17., 11.))\n", "ax = plt.subplot(111, projection=mapproj)\n", @@ -264,6 +221,13 @@ "\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/examples/HILO_Symbol_Plot.py b/examples/HILO_Symbol_Plot.py index 4132ff82f95..8a0225464a6 100644 --- a/examples/HILO_Symbol_Plot.py +++ b/examples/HILO_Symbol_Plot.py @@ -1,29 +1,13 @@ -#!/usr/bin/env python -# coding: utf-8 - -# In[ ]: - - -get_ipython().run_line_magic('matplotlib', 'inline') - - -# -# # MSLP and 1000-500 hPa Thickness with High and Low Symbols -# -# + # # MSLP and 1000-500 hPa Thickness with High and Low Symbols +# +# # Plot MSLP, calculate and plot 1000-500 hPa thickness, and plot H and L markers. # Beyond just plotting a few variables, in the example we use functionality # from the scipy module to find local maximum and minimimum values within the # MSLP field in order to plot symbols at those locations. -# +# # Imports -# -# - -# In[ ]: - - from datetime import datetime import cartopy.crs as ccrs @@ -35,80 +19,11 @@ from scipy.ndimage import gaussian_filter from siphon.ncss import NCSS -# Optional HiLo import for plot_maxmin_points module -from HiLo import plot_maxmin_points as plot_maxmin_points - - # Function for finding and plotting max/min points -# -# - -# In[ ]: - - -def plot_maxmin_points(ax, lon, lat, data, extrema, nsize, symbol,color='k', outline_color='k', - outline_width=2.5, press_spacing=0.66, plotValue=True, transform=None): - - """ - ax argument allows for sending current axis to the plot - - Path effects on the symbols and pressure readings - outline them in black (default) with linewidth - 2.5 (default) to make them pop a bit more. The press_spacing (0.66 default) is based off latitude and helps - serarate the pressure reading and the symbol with the outline effects making them overlap. - - - This function will find and plot relative maximum and minimum for a 2D grid. The function - can be used to plot an H for maximum values (e.g., High pressure) and an L for minimum - values (e.g., low pressue). It is best to used filetered data to obtain a synoptic scale - max/min value. The symbol text can be set to a string value and optionally the color of the - symbol and any plotted value can be set with the parameter color - lon = plotting longitude values (2D) - lat = plotting latitude values (2D) - data = 2D data that you wish to plot the max/min symbol placement - extrema = Either a value of max for Maximum Values or min for Minimum Values - nsize = Size of the grid box to filter the max and min values to plot a reasonable number - symbol = String to be placed at location of max/min value - color = String matplotlib colorname to plot the symbol (and numerica value, if plotted) - plot_value = Boolean (True/False) of whether to plot the numeric value of max/min point - The max/min symbol will be plotted on the current axes within the bounding frame - (e.g., clip_on=True) - """ - import numpy as np - from matplotlib import patheffects - from scipy.ndimage.filters import maximum_filter, minimum_filter - outline_effect = [patheffects.withStroke(linewidth=outline_width, foreground=outline_color)] - - if (extrema == 'max'): - data_ext = maximum_filter(data, nsize, mode='nearest') - elif (extrema == 'min'): - data_ext = minimum_filter(data, nsize, mode='nearest') - else: - raise ValueError('Value for hilo must be either max or min') - - mxy, mxx = np.where(data_ext == data) - #print(mxy,mxx) - - for i in range(len(mxy)): - symb_text = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]], symbol, color=color, size=24, - clip_on=True, horizontalalignment='center', verticalalignment='center', - transform=transform) - symb_text.set_path_effects(outline_effect) - - press_text = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]]-float(press_spacing), - str(np.int(data[mxy[i], mxx[i]])), - color=color, size=12, clip_on=True, fontweight='bold', - horizontalalignment='center', verticalalignment='top', transform=transform) - press_text.set_path_effects(outline_effect) - - +# import HiLo module for plot_maxmin_points function +from HiLo import plot_maxmin_points as plot_maxmin_points # Get NARR data -# -# - -# In[ ]: - - dattim = datetime(1999, 1, 3, 0) ncss = NCSS('https://www.ncei.noaa.gov/thredds/ncss/grid/narr-a-files/{0:%Y%m}/{0:%Y%m%d}/' @@ -120,12 +35,6 @@ def plot_maxmin_points(ax, lon, lat, data, extrema, nsize, symbol,color='k', out # Extract data into variables -# -# - -# In[ ]: - - # Grab pressure levels plev = list(data.variables['isobaric1'][:]) @@ -152,12 +61,6 @@ def plot_maxmin_points(ax, lon, lat, data, extrema, nsize, symbol,color='k', out # Set map and data projections for use in mapping -# -# - -# In[ ]: - - # Set projection of map display mapproj = ccrs.LambertConformal(central_latitude=45., central_longitude=-100.) @@ -173,12 +76,6 @@ def plot_maxmin_points(ax, lon, lat, data, extrema, nsize, symbol,color='k', out # Create figure and plot data -# -# - -# In[ ]: - - fig = plt.figure(1, figsize=(17., 11.)) ax = plt.subplot(111, projection=mapproj) @@ -214,4 +111,3 @@ def plot_maxmin_points(ax, lon, lat, data, extrema, nsize, symbol,color='k', out plt.title('VALID: {}'.format(vtime[0]), loc='right') plt.show() - From 1c709993aeb1400caec291b2575bcd51af424565 Mon Sep 17 00:00:00 2001 From: MethaneRain Date: Wed, 7 Oct 2020 14:22:37 +0000 Subject: [PATCH 5/5] update HiLo script --- HiLo.py | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/HiLo.py b/HiLo.py index ff940181460..c31a7e19e59 100644 --- a/HiLo.py +++ b/HiLo.py @@ -7,13 +7,13 @@ def plot_maxmin_points(ax,lon, lat, data, extrema, nsize, symbol,color='k', outl outline_width=2.5, press_spacing=0.66,plotValue=True, transform=None): """ - ax argument allows for sending current axis to the HiLo plot - - Path effects on the symbols and pressure readings - outline them in black (default) with linewidth - 2.5 (default) to make them pop a bit more. The press_spacing (0.66 default) is based off latitude and helps + ax argument allows for sending current axis to the HiLo plot + + Path effects on the symbols and pressure readings - outline them in black (default) with linewidth + 2.5 (default) to make them pop a bit more. The press_spacing (0.66 default) is based off latitude and helps serarate the pressure reading and the symbol with the outline effects making them overlap. - - + + This function will find and plot relative maximum and minimum for a 2D grid. The function can be used to plot an H for maximum values (e.g., High pressure) and an L for minimum values (e.g., low pressue). It is best to used filetered data to obtain a synoptic scale @@ -41,9 +41,8 @@ def plot_maxmin_points(ax,lon, lat, data, extrema, nsize, symbol,color='k', outl data_ext = minimum_filter(data, nsize, mode='nearest') else: raise ValueError('Value for hilo must be either max or min') - + mxy, mxx = np.where(data_ext == data) - #print(mxy,mxx) for i in range(len(mxy)): A = ax.text(lon[mxy[i], mxx[i]], lat[mxy[i], mxx[i]], symbol, color=color, size=24, @@ -55,5 +54,3 @@ def plot_maxmin_points(ax,lon, lat, data, extrema, nsize, symbol,color='k', outl color=color, size=12, clip_on=True, fontweight='bold', horizontalalignment='center', verticalalignment='top', transform=transform) B.set_path_effects(outline_effect) - -