From 9044962aedc7c94a149104de2aafd532e443b46e Mon Sep 17 00:00:00 2001 From: Kevin Dougherty <69815622+kevindougherty-noaa@users.noreply.github.com> Date: Tue, 9 Jul 2024 14:02:10 -0400 Subject: [PATCH] Updating plotting documentation - adding new gallery (#143) * updates to documentation for additional gallery * testing changes * pycodestyle * pycodestyle * try new matplotlib * add plot type example files for gallery * pycodestyle * update plots markdown * histograms/histogram.py * update order and remove examples * add subsection order * one last fix * Delete galleries/examples/line_plots/Untitled.ipynb * Delete docs/sphinxext/gallery_order.py * Delete docs/sphinxext/__init__.py --- docs/conf.py | 38 +++-- docs/getting_started/plots.md | 17 +- docs/index.rst | 3 +- examples/__init__.py | 0 {examples => galleries/examples}/README.txt | 8 +- .../examples}/histograms/README.txt | 0 .../examples}/histograms/layered_histogram.py | 0 .../examples}/line_plots/README.txt | 0 .../examples}/line_plots/SkewT.py | 0 .../line_plots/inverted_log_scale.py | 0 .../examples}/line_plots/line_plot_options.py | 0 .../examples}/line_plots/multi_line_plot.py | 0 .../examples}/map_plots/README.txt | 0 .../map_plots/Test_Example_Plots.ipynb | 145 ++++++++++++++++++ .../examples}/map_plots/custom_map_domain.py | 0 .../examples}/map_plots/map_plot_no_data.py | 0 .../examples}/map_plots/map_scatter_2D.py | 0 .../examples}/scatter_plots/README.txt | 0 .../scatter_with_regression_line.py | 0 galleries/plot_types/README.txt | 6 + galleries/plot_types/basic/README.txt | 4 + galleries/plot_types/basic/bar.py | 54 +++++++ galleries/plot_types/basic/horizontal_bar.py | 54 +++++++ galleries/plot_types/basic/horizontal_line.py | 45 ++++++ .../plot_types/basic/line.py | 8 +- .../plot_types/basic}/scatter.py | 29 ++-- galleries/plot_types/basic/vertical_line.py | 45 ++++++ galleries/plot_types/gridded/README.txt | 4 + galleries/plot_types/gridded/contour.py | 56 +++++++ galleries/plot_types/gridded/contourf.py | 56 +++++++ galleries/plot_types/gridded/gridded.py | 56 +++++++ galleries/plot_types/map/README.txt | 4 + .../plot_types/map}/map_gridded.py | 10 +- .../plot_types/map}/map_scatter.py | 12 +- galleries/plot_types/map/map_scatter_2D.py | 49 ++++++ galleries/plot_types/statistical/README.txt | 4 + galleries/plot_types/statistical/boxplot.py | 55 +++++++ galleries/plot_types/statistical/density.py | 53 +++++++ .../statistical}/density_scatter.py | 6 +- .../plot_types/statistical}/histogram.py | 43 ++++-- requirements-github.txt | 2 +- src/emcpy/plots/create_plots.py | 4 +- src/emcpy/plots/plots.py | 1 + 43 files changed, 809 insertions(+), 62 deletions(-) delete mode 100644 examples/__init__.py rename {examples => galleries/examples}/README.txt (86%) rename {examples => galleries/examples}/histograms/README.txt (100%) rename {examples => galleries/examples}/histograms/layered_histogram.py (100%) rename {examples => galleries/examples}/line_plots/README.txt (100%) rename {examples => galleries/examples}/line_plots/SkewT.py (100%) rename {examples => galleries/examples}/line_plots/inverted_log_scale.py (100%) rename {examples => galleries/examples}/line_plots/line_plot_options.py (100%) rename {examples => galleries/examples}/line_plots/multi_line_plot.py (100%) rename {examples => galleries/examples}/map_plots/README.txt (100%) create mode 100644 galleries/examples/map_plots/Test_Example_Plots.ipynb rename {examples => galleries/examples}/map_plots/custom_map_domain.py (100%) rename {examples => galleries/examples}/map_plots/map_plot_no_data.py (100%) rename {examples => galleries/examples}/map_plots/map_scatter_2D.py (100%) rename {examples => galleries/examples}/scatter_plots/README.txt (100%) rename {examples => galleries/examples}/scatter_plots/scatter_with_regression_line.py (100%) create mode 100644 galleries/plot_types/README.txt create mode 100644 galleries/plot_types/basic/README.txt create mode 100644 galleries/plot_types/basic/bar.py create mode 100644 galleries/plot_types/basic/horizontal_bar.py create mode 100644 galleries/plot_types/basic/horizontal_line.py rename examples/line_plots/line_plot.py => galleries/plot_types/basic/line.py (85%) rename {examples/scatter_plots => galleries/plot_types/basic}/scatter.py (61%) create mode 100644 galleries/plot_types/basic/vertical_line.py create mode 100644 galleries/plot_types/gridded/README.txt create mode 100644 galleries/plot_types/gridded/contour.py create mode 100644 galleries/plot_types/gridded/contourf.py create mode 100644 galleries/plot_types/gridded/gridded.py create mode 100644 galleries/plot_types/map/README.txt rename {examples/map_plots => galleries/plot_types/map}/map_gridded.py (89%) rename {examples/map_plots => galleries/plot_types/map}/map_scatter.py (86%) create mode 100644 galleries/plot_types/map/map_scatter_2D.py create mode 100644 galleries/plot_types/statistical/README.txt create mode 100644 galleries/plot_types/statistical/boxplot.py create mode 100644 galleries/plot_types/statistical/density.py rename {examples/scatter_plots => galleries/plot_types/statistical}/density_scatter.py (87%) rename {examples/histograms => galleries/plot_types/statistical}/histogram.py (57%) diff --git a/docs/conf.py b/docs/conf.py index 00dd0d47..0c3c7814 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -17,7 +17,7 @@ sys.path.insert(0, str(Path(__file__).parent.resolve())) import matplotlib -from sphinx_gallery.sorting import ExampleTitleSortKey, ExplicitOrder +from sphinx_gallery.sorting import ExplicitOrder import emcpy @@ -44,33 +44,49 @@ ] +# Sphinx gallery configuration +# gallery_order.py from the sphinxext folder provides the classes that +# allow custom ordering of sections and subsections of the gallery +from sphinxext.gallery_order import ( + sectionorder as gallery_order_sectionorder, + subsectionorder as gallery_order_subsectionorder) + +# Create gallery dirs +gallery_dirs = ["examples", "plot_types"] +example_dirs = [] +for gd in gallery_dirs: + gd = gd.replace('gallery', 'examples') + example_dirs += [f'../galleries/{gd}'] + # Sphinx gallery configuration subsection_order = ExplicitOrder([ - '../examples/line_plots', - '../examples/scatter_plots', - '../examples/histograms', - '../examples/map_plots' + '../galleries/plot_types/basic', + '../galleries/plot_types/statistical', + '../galleries/plot_types/gridded', + '../galleries/plot_types/map', + '../galleries/examples/line_plots', + '../galleries/examples/scatter_plots', + '../galleries/examples/histograms', + '../galleries/examples/map_plots' ]) sphinx_gallery_conf = { 'capture_repr': (), 'filename_pattern': '^((?!skip_).)*$', - 'examples_dirs': ['../examples'], # path to example scripts - 'gallery_dirs': ['gallery'], # path to where to save gallery generated output + 'examples_dirs': ['../galleries/examples', '../galleries/plot_types'], + 'gallery_dirs': ['examples', 'plot_types'], # path to where to save gallery generated output 'backreferences_dir': '../build/backrefs', 'subsection_order': subsection_order, - 'within_subsection_order': ExampleTitleSortKey, - 'matplotlib_animations': True, + 'matplotlib_animations': True } - # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] +exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store', '.ipynb'] # -- Options for HTML output ------------------------------------------------- diff --git a/docs/getting_started/plots.md b/docs/getting_started/plots.md index 331c6339..ed5efc12 100644 --- a/docs/getting_started/plots.md +++ b/docs/getting_started/plots.md @@ -1,3 +1,18 @@ ## Plots -Coming soon! \ No newline at end of file +The plotting section of EMCPy is the most mature and is used as the backend plotting for [eva](https://github.com/JCSDA-internal/eva). It uses declarative, object-oriented programming approach to handle complex plotting routines under the hood to simplify the experience for novice users while remaining robust so more experienced users can utilize higher-level applications. + +### Design +The design was inspired by Unidata's [MetPy](https://github.com/Unidata/MetPy) declarative plotting syntax. The structure is broken into three different levels: plot type level, plot level, figure level + +#### Plot Type Level +This is the level where users will define their plot type objects and associated plot details. This includes adding the related data the user wants to plot and how the user wants to display the data i.e: color, line style, marker style, labels, etc. + +#### Plot Level +This level is where users design how they want the overall subplot to look. Users can add multiple plot type objects and define titles, x and y labels, colorbars, legends, etc. + +#### Figure Level +This level where users defines high-level specifics about the actual figure itself. These include figure size, layout, defining information about subplot layouts like rows and columns, saving the figure, etc. + + +For the current available plot types in EMCPy, see [Plot Types](../plot_types/index.rst). diff --git a/docs/index.rst b/docs/index.rst index 008e3c74..58f301c1 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -10,7 +10,8 @@ EMCPy :hidden: getting_started/index - gallery/index + plot_types/index + examples/index installing diff --git a/examples/__init__.py b/examples/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/examples/README.txt b/galleries/examples/README.txt similarity index 86% rename from examples/README.txt rename to galleries/examples/README.txt index e8462aa8..560cd7ec 100644 --- a/examples/README.txt +++ b/galleries/examples/README.txt @@ -1,6 +1,8 @@ -Gallery -------- +.. _examples: + +Examples +-------- The following examples show off the functionality of EMCPy. The examples give reference to what can be done with these collection of tools. Please -do not hesitate to issue a pull request to add further examples! \ No newline at end of file +do not hesitate to issue a pull request to add further examples! diff --git a/examples/histograms/README.txt b/galleries/examples/histograms/README.txt similarity index 100% rename from examples/histograms/README.txt rename to galleries/examples/histograms/README.txt diff --git a/examples/histograms/layered_histogram.py b/galleries/examples/histograms/layered_histogram.py similarity index 100% rename from examples/histograms/layered_histogram.py rename to galleries/examples/histograms/layered_histogram.py diff --git a/examples/line_plots/README.txt b/galleries/examples/line_plots/README.txt similarity index 100% rename from examples/line_plots/README.txt rename to galleries/examples/line_plots/README.txt diff --git a/examples/line_plots/SkewT.py b/galleries/examples/line_plots/SkewT.py similarity index 100% rename from examples/line_plots/SkewT.py rename to galleries/examples/line_plots/SkewT.py diff --git a/examples/line_plots/inverted_log_scale.py b/galleries/examples/line_plots/inverted_log_scale.py similarity index 100% rename from examples/line_plots/inverted_log_scale.py rename to galleries/examples/line_plots/inverted_log_scale.py diff --git a/examples/line_plots/line_plot_options.py b/galleries/examples/line_plots/line_plot_options.py similarity index 100% rename from examples/line_plots/line_plot_options.py rename to galleries/examples/line_plots/line_plot_options.py diff --git a/examples/line_plots/multi_line_plot.py b/galleries/examples/line_plots/multi_line_plot.py similarity index 100% rename from examples/line_plots/multi_line_plot.py rename to galleries/examples/line_plots/multi_line_plot.py diff --git a/examples/map_plots/README.txt b/galleries/examples/map_plots/README.txt similarity index 100% rename from examples/map_plots/README.txt rename to galleries/examples/map_plots/README.txt diff --git a/galleries/examples/map_plots/Test_Example_Plots.ipynb b/galleries/examples/map_plots/Test_Example_Plots.ipynb new file mode 100644 index 00000000..9f49448d --- /dev/null +++ b/galleries/examples/map_plots/Test_Example_Plots.ipynb @@ -0,0 +1,145 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append('/scratch1/NCEPDEV/da/Kevin.Dougherty/emcpy/src/')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from emcpy.plots import CreatePlot, CreateFigure\n", + "from emcpy.plots.map_tools import Domain, MapProjection\n", + "\n", + "# Create dictionary with information pertaining to\n", + "# Africa domain\n", + "africa_dict = {\n", + " \"extent\": (-20, 55, -35, 35),\n", + " \"xticks\": (-15, 0, 15, 30, 45),\n", + " \"yticks\": (-30, -15, 0, 15, 30),\n", + " \"cenlon\": 20.,\n", + " \"cenlat\": -10.\n", + "}\n", + "\n", + "# Create plot object and add features\n", + "plot1 = CreatePlot()\n", + "plot1.projection = 'plcarr'\n", + "# Add data as a tuple with 'custom' as domain name\n", + "# and `africa_dict` as dictionary\n", + "plot1.domain = ('custom', africa_dict)\n", + "plot1.add_map_features(['coastline'])\n", + "plot1.add_xlabel(xlabel='longitude')\n", + "plot1.add_ylabel(ylabel='latitude')\n", + "plot1.add_title(label='Custom Africa Domain', loc='center',\n", + " fontsize=12)\n", + "\n", + "fig = CreateFigure()\n", + "fig.plot_list = [plot1]\n", + "fig.create_figure()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from emcpy.plots import CreatePlot, CreateFigure\n", + "from emcpy.plots.map_tools import Domain, MapProjection\n", + "from emcpy.plots.map_plots import MapScatter\n", + "\n", + "lats = np.linspace(35, 50, 30)\n", + "lons = np.linspace(-70, -120, 30)\n", + "\n", + "# Create scatter plot on CONUS domian\n", + "scatter = MapScatter(lats, lons)\n", + "# change colormap and markersize\n", + "scatter.color = 'tab:red'\n", + "scatter.markersize = 25\n", + "\n", + "# Create plot object and add features\n", + "plot1 = CreatePlot()\n", + "plot1.plot_layers = [scatter]\n", + "plot1.projection = 'plcarr'\n", + "plot1.domain = 'conus'\n", + "plot1.add_map_features(['coastline', 'states'])\n", + "plot1.add_xlabel(xlabel='longitude')\n", + "plot1.add_ylabel(ylabel='latitude')\n", + "plot1.add_title(label='EMCPy Map', loc='center',\n", + " fontsize=20)\n", + "\n", + "fig = CreateFigure()\n", + "fig.plot_list = [plot1]\n", + "fig.create_figure()\n", + "fig.save_figure('map_scatter_2D.png')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/map_plots/custom_map_domain.py b/galleries/examples/map_plots/custom_map_domain.py similarity index 100% rename from examples/map_plots/custom_map_domain.py rename to galleries/examples/map_plots/custom_map_domain.py diff --git a/examples/map_plots/map_plot_no_data.py b/galleries/examples/map_plots/map_plot_no_data.py similarity index 100% rename from examples/map_plots/map_plot_no_data.py rename to galleries/examples/map_plots/map_plot_no_data.py diff --git a/examples/map_plots/map_scatter_2D.py b/galleries/examples/map_plots/map_scatter_2D.py similarity index 100% rename from examples/map_plots/map_scatter_2D.py rename to galleries/examples/map_plots/map_scatter_2D.py diff --git a/examples/scatter_plots/README.txt b/galleries/examples/scatter_plots/README.txt similarity index 100% rename from examples/scatter_plots/README.txt rename to galleries/examples/scatter_plots/README.txt diff --git a/examples/scatter_plots/scatter_with_regression_line.py b/galleries/examples/scatter_plots/scatter_with_regression_line.py similarity index 100% rename from examples/scatter_plots/scatter_with_regression_line.py rename to galleries/examples/scatter_plots/scatter_with_regression_line.py diff --git a/galleries/plot_types/README.txt b/galleries/plot_types/README.txt new file mode 100644 index 00000000..65c59018 --- /dev/null +++ b/galleries/plot_types/README.txt @@ -0,0 +1,6 @@ +.. _plot-types: + +Plot Types +---------- + +Here is a collection of the plot types that are currently available using EMCPy. diff --git a/galleries/plot_types/basic/README.txt b/galleries/plot_types/basic/README.txt new file mode 100644 index 00000000..02ad2572 --- /dev/null +++ b/galleries/plot_types/basic/README.txt @@ -0,0 +1,4 @@ +.. _basic: + +Basic +===== diff --git a/galleries/plot_types/basic/bar.py b/galleries/plot_types/basic/bar.py new file mode 100644 index 00000000..e3d007b6 --- /dev/null +++ b/galleries/plot_types/basic/bar.py @@ -0,0 +1,54 @@ +""" +Bar Plot +-------- + +Below is an example of how to plot a bar +plot using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots.plots import BarPlot +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + # Create bar plot + + # Grab sample bar plot data + x_pos, heights = _getBarData() + + # Create bar plot object + bar = BarPlot(x_pos, heights) + bar.color = 'tab:red' + + # Create plot object and add features + plot1 = CreatePlot() + plot1.plot_layers = [bar] + plot1.add_xlabel(xlabel='X Axis Label') + plot1.add_ylabel(ylabel='Y Axis Label') + plot1.add_title("Bar Plot") + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +def _getBarData(): + # Generate test data for bar graphs + + x = ['a', 'b', 'c', 'd', 'e', 'f'] + heights = [5, 6, 15, 22, 24, 8] + + x_pos = [i for i, _ in enumerate(x)] + + return x_pos, heights + + +if __name__ == '__main__': + main() diff --git a/galleries/plot_types/basic/horizontal_bar.py b/galleries/plot_types/basic/horizontal_bar.py new file mode 100644 index 00000000..10e03c6e --- /dev/null +++ b/galleries/plot_types/basic/horizontal_bar.py @@ -0,0 +1,54 @@ +""" +Horizontal Bar Plot +------------------- + +Below is an example of how to plot a horizontal +bar plot using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots.plots import HorizontalBar +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + # Create horizontal bar plot + + # Grab sample bar plot data + y_pos, widths = _getBarData() + + # Create horizontal bar plot object + bar = HorizontalBar(y_pos, widths) + bar.color = 'tab:green' + + # Create plot object and add features + plot1 = CreatePlot() + plot1.plot_layers = [bar] + plot1.add_xlabel(xlabel='X Axis Label') + plot1.add_ylabel(ylabel='Y Axis Label') + plot1.add_title("Horizontal Bar Plot") + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +def _getBarData(): + # Generate test data for bar graphs + + x = ['a', 'b', 'c', 'd', 'e', 'f'] + heights = [5, 6, 15, 22, 24, 8] + + x_pos = [i for i, _ in enumerate(x)] + + return x_pos, heights + + +if __name__ == '__main__': + main() diff --git a/galleries/plot_types/basic/horizontal_line.py b/galleries/plot_types/basic/horizontal_line.py new file mode 100644 index 00000000..e1f88428 --- /dev/null +++ b/galleries/plot_types/basic/horizontal_line.py @@ -0,0 +1,45 @@ +""" +Horizontal Line Plot +-------------------- + +Below is an example of how to plot a horizontal +line using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots.plots import HorizontalLine +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + + y = 5 + + # Create vertical line plot object + hlp = HorizontalLine(y) + hlp.label = 'Horizontal Line' + + # Add vertical line plot object to list + plt_list = [hlp] + + # Create plot object and add features + plot1 = CreatePlot() + plot1.plot_layers = [hlp] + plot1.add_title('Horizontal Line Plot') + plot1.add_xlabel('X Axis Label') + plot1.add_ylabel('Y Axis Label') + plot1.add_legend(loc='upper right') + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +if __name__ == '__main__': + main() diff --git a/examples/line_plots/line_plot.py b/galleries/plot_types/basic/line.py similarity index 85% rename from examples/line_plots/line_plot.py rename to galleries/plot_types/basic/line.py index e041cc9c..bf055e87 100644 --- a/examples/line_plots/line_plot.py +++ b/galleries/plot_types/basic/line.py @@ -1,6 +1,6 @@ """ -Creating a simple line plot ---------------------------- +Line Plot +--------- Below is an example of how to plot a basic line plot using EMCPy's plotting method. @@ -29,12 +29,12 @@ def main(): # Create plot object and add features plot1 = CreatePlot() plot1.plot_layers = [lp] - plot1.add_title('Test Line Plot') + plot1.add_title('Line Plot') plot1.add_xlabel('X Axis Label') plot1.add_ylabel('Y Axis Label') plot1.add_legend(loc='upper right') - # Create figure and save as png + # Create figure fig = CreateFigure() fig.plot_list = [plot1] fig.create_figure() diff --git a/examples/scatter_plots/scatter.py b/galleries/plot_types/basic/scatter.py similarity index 61% rename from examples/scatter_plots/scatter.py rename to galleries/plot_types/basic/scatter.py index d5ca4e70..fa4aa2b2 100644 --- a/examples/scatter_plots/scatter.py +++ b/galleries/plot_types/basic/scatter.py @@ -1,6 +1,6 @@ """ -Creating a simple scatter plot ------------------------------- +Scatter Plot +------------ Below is an example of how to plot a basic scatter plot using EMCPy's plotting method. @@ -15,18 +15,15 @@ def main(): - # Create test data - rng = np.random.RandomState(0) - x = rng.randn(100) - y = rng.randn(100) - # Create Scatter object - sctr1 = Scatter(x, y) + # Create scatter plot object + x1, y1, x2, y2 = _getScatterData() + sctr1 = Scatter(x1, y1) # Create plot object and add features plot1 = CreatePlot() plot1.plot_layers = [sctr1] - plot1.add_title(label='Test Scatter Plot') + plot1.add_title(label='Scatter Plot') plot1.add_xlabel(xlabel='X Axis Label') plot1.add_ylabel(ylabel='Y Axis Label') @@ -38,5 +35,19 @@ def main(): plt.show() +def _getScatterData(): + # Generate test data for scatter plots + + rng = np.random.RandomState(0) + x1 = rng.randn(100) + y1 = rng.randn(100) + + rng = np.random.RandomState(0) + x2 = rng.randn(30) + y2 = rng.randn(30) + + return x1, y1, x2, y2 + + if __name__ == '__main__': main() diff --git a/galleries/plot_types/basic/vertical_line.py b/galleries/plot_types/basic/vertical_line.py new file mode 100644 index 00000000..2562e333 --- /dev/null +++ b/galleries/plot_types/basic/vertical_line.py @@ -0,0 +1,45 @@ +""" +Vertical Line Plot +------------------ + +Below is an example of how to plot a vertical +line using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots.plots import VerticalLine +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + + x = 5 + + # Create vertical line plot object + vlp = VerticalLine(x) + vlp.label = 'Vertical Line' + + # Add vertical line plot object to list + plt_list = [vlp] + + # Create plot object and add features + plot1 = CreatePlot() + plot1.plot_layers = [vlp] + plot1.add_title('Vertical Line Plot') + plot1.add_xlabel('X Axis Label') + plot1.add_ylabel('Y Axis Label') + plot1.add_legend(loc='upper right') + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +if __name__ == '__main__': + main() diff --git a/galleries/plot_types/gridded/README.txt b/galleries/plot_types/gridded/README.txt new file mode 100644 index 00000000..9be9c8ad --- /dev/null +++ b/galleries/plot_types/gridded/README.txt @@ -0,0 +1,4 @@ +.. _gridded + +Gridded +======= diff --git a/galleries/plot_types/gridded/contour.py b/galleries/plot_types/gridded/contour.py new file mode 100644 index 00000000..c4be8e66 --- /dev/null +++ b/galleries/plot_types/gridded/contour.py @@ -0,0 +1,56 @@ +""" +Contour +------- + +Below is an example of how to plot a contour +plot using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots.plots import ContourPlot +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + # Create contourf plot + + # Grab sample data + x, y, z = _getContourData() + + # Create contour plot object + cp = ContourPlot(x, y, z) + cp.linestyles = '--' + cp.colors = 'green' + + # Create plot and add features + plot1 = CreatePlot() + plot1.plot_layers = [cp] + plot1.add_xlabel(xlabel='X Axis Label') + plot1.add_ylabel(ylabel='Y Axis Label') + plot1.add_title('Contour Plot') + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +def _getContourData(): + # Generate test data for contour plots + + x = np.linspace(-3, 15, 50).reshape(1, -1) + y = np.linspace(-3, 15, 20).reshape(-1, 1) + z = np.cos(x)*2 - np.sin(y)*2 + + x, y = x.flatten(), y.flatten() + + return x, y, z + + +if __name__ == '__main__': + main() diff --git a/galleries/plot_types/gridded/contourf.py b/galleries/plot_types/gridded/contourf.py new file mode 100644 index 00000000..6dae3ffe --- /dev/null +++ b/galleries/plot_types/gridded/contourf.py @@ -0,0 +1,56 @@ +""" +Filled Contour +-------------- + +Below is an example of how to plot a filled +contour plot using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots.plots import FilledContourPlot +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + # Create contourf plot + + # Grab sample data + x, y, z = _getContourfData() + + # Create filled contour plot object + cfp = FilledContourPlot(x, y, z) + cfp.cmap = 'Greens' + + # Create plot and add features + plot1 = CreatePlot() + plot1.plot_layers = [cfp] + plot1.add_xlabel(xlabel='X Axis Label') + plot1.add_ylabel(ylabel='Y Axis Label') + plot1.add_title('Filled Contour Plot') + plot1.add_colorbar(orientation='vertical') + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +def _getContourfData(): + # Generate test data for contourf plots + + x = np.linspace(-3, 15, 50).reshape(1, -1) + y = np.linspace(-3, 15, 20).reshape(-1, 1) + z = np.cos(x)*2 - np.sin(y)*2 + + x, y = x.flatten(), y.flatten() + + return x, y, z + + +if __name__ == '__main__': + main() diff --git a/galleries/plot_types/gridded/gridded.py b/galleries/plot_types/gridded/gridded.py new file mode 100644 index 00000000..bcfea42e --- /dev/null +++ b/galleries/plot_types/gridded/gridded.py @@ -0,0 +1,56 @@ +""" +Gridded +------- + +Below is an example of how to plot a gridded +plot using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt +from scipy.ndimage import gaussian_filter + +from emcpy.plots.plots import GriddedPlot +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + # Create gridded plot + + # Grab sample data + x, y, z = _getGriddedData() + + # Create gridded object + gp = GriddedPlot(x, y, z) + gp.cmap = 'plasma' + + # Create plot object and add features + plot1 = CreatePlot() + plot1.plot_layers = [gp] + plot1.add_xlabel(xlabel='X Axis Label') + plot1.add_ylabel(ylabel='Y Axis Label') + plot1.add_title('Gridded Plot') + plot1.add_colorbar(orientation='vertical') + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +def _getGriddedData(): + # Generate test data for gridded data + + x = np.linspace(0, 1, 51) + y = np.linspace(0, 1, 51) + r = np.random.RandomState(25) + z = gaussian_filter(r.random_sample([50, 50]), sigma=5, mode='wrap') + + return x, y, z + + +if __name__ == '__main__': + main() diff --git a/galleries/plot_types/map/README.txt b/galleries/plot_types/map/README.txt new file mode 100644 index 00000000..7d1a2266 --- /dev/null +++ b/galleries/plot_types/map/README.txt @@ -0,0 +1,4 @@ +.. _map_plots: + +Map Plots +========= diff --git a/examples/map_plots/map_gridded.py b/galleries/plot_types/map/map_gridded.py similarity index 89% rename from examples/map_plots/map_gridded.py rename to galleries/plot_types/map/map_gridded.py index 920ebfc1..198b47d2 100644 --- a/examples/map_plots/map_gridded.py +++ b/galleries/plot_types/map/map_gridded.py @@ -1,9 +1,11 @@ """ -Create a map plot with gridded data ------------------------------------ +Gridded Map Plot +---------------- + +Below is an example of how to plot +gridded data on a map plot using EMCPy's +plotting method. -The following example plots gridded data over -a CONUS domain. """ import numpy as np diff --git a/examples/map_plots/map_scatter.py b/galleries/plot_types/map/map_scatter.py similarity index 86% rename from examples/map_plots/map_scatter.py rename to galleries/plot_types/map/map_scatter.py index 1b0ff5e3..67cd3439 100644 --- a/examples/map_plots/map_scatter.py +++ b/galleries/plot_types/map/map_scatter.py @@ -1,11 +1,11 @@ """ -Creating a map plot with scatter data -------------------------------------- +Scatter Map Plot +---------------- + +Below is an example of how to plot +scatter data on a map plot using EMCPy's +plotting method. -The following example plots scatter data -on a map plot over a CONUS domain. This -example also shows how to annotate stats -on the plot. """ import numpy as np diff --git a/galleries/plot_types/map/map_scatter_2D.py b/galleries/plot_types/map/map_scatter_2D.py new file mode 100644 index 00000000..8ffdf3de --- /dev/null +++ b/galleries/plot_types/map/map_scatter_2D.py @@ -0,0 +1,49 @@ +""" +2D Scatter Map Plot +------------------- + +Below is an example of how to plot +2D data on a map plot using EMCPy's +plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots import CreatePlot, CreateFigure +from emcpy.plots.map_tools import Domain, MapProjection +from emcpy.plots.map_plots import MapScatter + + +def main(): + # Create test data + lats = np.linspace(35, 50, 30) + lons = np.linspace(-70, -120, 30) + + # Create scatter plot on CONUS domian + scatter = MapScatter(lats, lons) + # change colormap and markersize + scatter.color = 'tab:red' + scatter.markersize = 25 + + # Create plot object and add features + plot1 = CreatePlot() + plot1.plot_layers = [scatter] + plot1.projection = 'plcarr' + plot1.domain = 'conus' + plot1.add_map_features(['coastline', 'states']) + plot1.add_xlabel(xlabel='longitude') + plot1.add_ylabel(ylabel='latitude') + plot1.add_title(label='EMCPy Map', loc='center', + fontsize=20) + + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +if __name__ == '__main__': + main() diff --git a/galleries/plot_types/statistical/README.txt b/galleries/plot_types/statistical/README.txt new file mode 100644 index 00000000..131ae9d4 --- /dev/null +++ b/galleries/plot_types/statistical/README.txt @@ -0,0 +1,4 @@ +.. _statistical_distributions + +Statistical distributions +========================= diff --git a/galleries/plot_types/statistical/boxplot.py b/galleries/plot_types/statistical/boxplot.py new file mode 100644 index 00000000..61659b0f --- /dev/null +++ b/galleries/plot_types/statistical/boxplot.py @@ -0,0 +1,55 @@ +""" +Box Plot +-------- + +Below is an example of how to plot a box +plot using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots.plots import BoxandWhiskerPlot +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + # Create box and whisker plot + + # Grab sample data + data = _getBoxPlotData() + + # Create box plot object + bwp = BoxandWhiskerPlot(data) + bwp.label = 'Box Plot data' + + # Create plot object and add features + plot1 = CreatePlot() + plot1.plot_layers = [bwp] + plot1.add_xlabel(xlabel='X Axis Label') + plot1.add_ylabel(ylabel='Y Axis Label') + plot1.add_title('Test Box and Whisker Plot') + plot1.add_legend(loc='upper left') + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +def _getBoxPlotData(): + # Generate test data for box and whisker plot + + # Fixing random state for reproducibility + np.random.seed(19680801) + + data = [np.random.normal(0, std, 100) for std in range(6, 10)] + + return data + + +if __name__ == '__main__': + main() diff --git a/galleries/plot_types/statistical/density.py b/galleries/plot_types/statistical/density.py new file mode 100644 index 00000000..994ee6be --- /dev/null +++ b/galleries/plot_types/statistical/density.py @@ -0,0 +1,53 @@ +""" +Density +------- + +Below is an example of how to plot a density +histogram plot using EMCPy's plotting method. + +""" + +import numpy as np +import matplotlib.pyplot as plt + +from emcpy.plots.plots import Density +from emcpy.plots.create_plots import CreatePlot, CreateFigure + + +def main(): + # Test density plot + + # Grab sample data + data = _getHistData() + + # Create density object + den1 = Density(data) + den1.label = 'Density' + + # Create plot object and add features + plot1 = CreatePlot() + plot1.plot_layers = [den1] + plot1.add_title(label='Density Plot') + plot1.add_xlabel(xlabel='X Axis Label') + plot1.add_ylabel(ylabel='Y Axis Label') + + # Create figure + fig = CreateFigure() + fig.plot_list = [plot1] + fig.create_figure() + + plt.show() + + +def _getHistData(): + # Generate test data for histogram plots + + mu = 100 # mean of distribution + sigma = 15 # standard deviation of distribution + data = mu + sigma * np.random.randn(437) + + return data + + +if __name__ == '__main__': + main() diff --git a/examples/scatter_plots/density_scatter.py b/galleries/plot_types/statistical/density_scatter.py similarity index 87% rename from examples/scatter_plots/density_scatter.py rename to galleries/plot_types/statistical/density_scatter.py index 146ed706..d67f1f2d 100644 --- a/examples/scatter_plots/density_scatter.py +++ b/galleries/plot_types/statistical/density_scatter.py @@ -1,6 +1,6 @@ """ -Creating a Density Scatter Plot -------------------------------- +Density Scatter Plot +-------------------- The following example shows how to create a density scatter plot. @@ -26,7 +26,7 @@ def main(): # Create plot object and add features plot1 = CreatePlot() plot1.plot_layers = [sctr1] - plot1.add_title(label='Test Density Scatter Plot') + plot1.add_title(label='Density Scatter Plot') plot1.add_xlabel(xlabel='X Axis Label') plot1.add_ylabel(ylabel='Y Axis Label') plot1.add_legend() diff --git a/examples/histograms/histogram.py b/galleries/plot_types/statistical/histogram.py similarity index 57% rename from examples/histograms/histogram.py rename to galleries/plot_types/statistical/histogram.py index d345dbee..b4bbc8c8 100644 --- a/examples/histograms/histogram.py +++ b/galleries/plot_types/statistical/histogram.py @@ -1,9 +1,9 @@ """ -Creating a simple histogram ---------------------------- +Histogram +--------- -Below is an example of how to plot a basic -histogram plot using EMCPy's plotting method. +Below is an example of how to plot a histogram +using EMCPy's plotting method. """ @@ -15,26 +15,25 @@ def main(): - # Generate test data for histogram plots - mu = 100 # mean of distribution - sigma = 15 # standard deviation of distribution - data = mu + sigma * np.random.randn(437) + # Create histogram plot + + # Grab sample data + data = _getHistData() # Create histogram object - hst = Histogram(data) - hst.color = 'tab:green' - hst.alpha = 0.7 - hst.label = 'data' + hst1 = Histogram(data) + hst1.color = 'tab:green' + hst1.label = 'data' - # Create histogram plot object and add features + # Create plot object and add features plot1 = CreatePlot() - plot1.plot_layers = [hst] - plot1.add_title(label='Test Histogram Plot') + plot1.plot_layers = [hst1] + plot1.add_title(label='Histogram Plot') plot1.add_xlabel(xlabel='X Axis Label') plot1.add_ylabel(ylabel='Y Axis Label') - plot1.add_legend() + plot1.add_legend(loc='upper right') - # Create figure and save as png + # Create figure fig = CreateFigure() fig.plot_list = [plot1] fig.create_figure() @@ -42,5 +41,15 @@ def main(): plt.show() +def _getHistData(): + # Generate test data for histogram plots + + mu = 100 # mean of distribution + sigma = 15 # standard deviation of distribution + data = mu + sigma * np.random.randn(437) + + return data + + if __name__ == '__main__': main() diff --git a/requirements-github.txt b/requirements-github.txt index f03954f5..24f862d0 100644 --- a/requirements-github.txt +++ b/requirements-github.txt @@ -1,7 +1,7 @@ pyyaml>=6.0 pycodestyle>=2.9.1 netCDF4>=1.6.1 -matplotlib==3.5.2 +matplotlib==3.9.0 cartopy>=0.21.1 scikit-learn>=1.1.2 xarray>=2022.6.0 diff --git a/src/emcpy/plots/create_plots.py b/src/emcpy/plots/create_plots.py index df755e6b..b5f5b728 100644 --- a/src/emcpy/plots/create_plots.py +++ b/src/emcpy/plots/create_plots.py @@ -773,8 +773,8 @@ def _plot_legend(self, ax, legend): """ leg = ax.legend(**legend) - for i, key in enumerate(leg.legendHandles): - leg.legendHandles[i]._sizes = [20] + for handle in leg.legend_handles: + handle._sizes = [20] def _plot_text(self, ax, text_in): """ diff --git a/src/emcpy/plots/plots.py b/src/emcpy/plots/plots.py index 713097b9..91f681be 100644 --- a/src/emcpy/plots/plots.py +++ b/src/emcpy/plots/plots.py @@ -203,6 +203,7 @@ def __init__(self, x, y, z): self.extent = None self.locator = None self.extend = None + self.levels = None self.colorbar = False