From 093eb5f19eca2e1a49e9c6292f2f499c13671a74 Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 12 Aug 2021 11:35:58 -0400 Subject: [PATCH 01/45] initial commit - in progress notebooks --- .../example_notebook_grass_jupyter.ipynb | 179 +++++++++ doc/notebooks/hydrology.ipynb | 376 ++++++++++++++++++ 2 files changed, 555 insertions(+) create mode 100644 doc/notebooks/example_notebook_grass_jupyter.ipynb create mode 100644 doc/notebooks/hydrology.ipynb diff --git a/doc/notebooks/example_notebook_grass_jupyter.ipynb b/doc/notebooks/example_notebook_grass_jupyter.ipynb new file mode 100644 index 00000000000..fb6fdf68e0b --- /dev/null +++ b/doc/notebooks/example_notebook_grass_jupyter.ipynb @@ -0,0 +1,179 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Try GRASS GIS in Jupyter Notebook with Python and grass.jupyter\n", + "\n", + "[\"GRASS](https://grass.osgeo.org/)\n", + "\n", + "This is a quick introduction to *GRASS GIS* in a *Jupyter Notebook* using the `grass.jupyter` package and the *Python* scripting language. The `grass.jupyter` package shortens the launch of *GRASS GIS* in *Jupyter Notebook* and provides several useful classes for creating, displaying and saving *GRASS GIS* maps. This notebook can be directly compared with `example_notebook.ipynb` to see how the package improves the integration of *GRASS GIS* and *Jupyter Notebooks*.\n", + "\n", + "\n", + "The `grass.jupyter` package was written as part of Google Summer of Code in 2021. For more information, visit the [wiki page](https://trac.osgeo.org/grass/wiki/GSoC/2021/JupyterAndGRASS).\n", + "\n", + "\n", + "Examples here are using a sample GRASS GIS dataset for North Carolina, USA. The dataset is included in this environment.\n", + "\n", + "## Usage\n", + "\n", + "To run the selected part which is called a cell, hit `Shift + Enter`.\n", + "\n", + "## Start\n", + "\n", + "There are several ways to use GRASS GIS. When using Python in a notebook, we usually find GRASS GIS Python packages first, import them, initialize GRASS GIS session, and set several variables useful for using GRASS GIS in a notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Import Python standard library and IPython packages we need.\n", + "import os\n", + "import subprocess\n", + "import sys\n", + "\n", + "# Ask GRASS GIS where its Python packages are.\n", + "gisbase = subprocess.check_output([\"grass\", \"--config\", \"path\"], text=True).strip()\n", + "os.environ[\"GISBASE\"] = gisbase\n", + "sys.path.append(os.path.join(gisbase, \"etc\", \"python\"))\n", + "\n", + "# Import the GRASS GIS packages we need.\n", + "import grass.script as gs\n", + "import grass.jupyter as gj\n", + "\n", + "# Start GRASS Session\n", + "gj.init(\"../../data/grassdata\", \"nc_basic_spm_grass7\", \"user1\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Raster buffer\n", + "\n", + "Set computational region and create multiple buffers in given distances\n", + "around lakes represented as raster:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gs.parse_command('g.region', raster=\"lakes\", flags='pg')\n", + "gs.run_command('r.buffer', input=\"lakes\", output=\"lakes_buff\", distances=[60, 120, 240, 500])\n", + "\n", + "# Start a GrassRenderer map\n", + "r = gj.GrassRenderer()\n", + "\n", + "# Add a raster and vector to the map\n", + "r.d_rast(map=\"lakes_buff\")\n", + "r.d_legend(raster=\"lakes_buff\", range=(2, 5), at=(80, 100, 2, 10), flags=\"b\")\n", + "\n", + "# Display map\n", + "r.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Vector buffer\n", + "\n", + "Create a negative buffer around state boundary represented as a vector.\n", + "Vector modules typically don't follow computational region,\n", + "but we set it to inform display modules about our area of interest." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gs.run_command('v.buffer', input=\"boundary_state\", output=\"buffer\", distance=-10000)\n", + "gs.parse_command('g.region', vector=\"boundary_state\", flags='pg')\n", + "\n", + "# Start another GrassRenderer Map\n", + "m = gj.GrassRenderer()\n", + "\n", + "# Add vector layers and legend\n", + "m.d_vect(map=\"boundary_state\", fill_color=\"#5A91ED\", legend_label=\"State boundary\")\n", + "m.d_vect(map=\"buffer\", fill_color=\"#F8766D\", legend_label=\"Inner portion\")\n", + "m.d_legend_vect(at=(10, 35))\n", + "\n", + "# Display map\n", + "m.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Additional GRASS Information and Tutorials\n", + "\n", + "To find more information on what one can do with GRASS GIS APIs, check out:\n", + " \n", + " - [GRASS GIS Manual](https://grass.osgeo.org/grass-stable/manuals)\n", + " \n", + " - [GRASS Python API Manual](https://grass.osgeo.org/grass-stable/manuals/libpython)\n", + "\n", + "For more Jupyter Notebook GRASS GIS tutorials, visit:\n", + " - [Try GRASS GIS online](https://grass.osgeo.org/learn/tryonline/)\n", + "\n", + "## What else is in the sample North Carolina dataset?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(gs.read_command(\"g.list\", type=\"all\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What other GRASS modules can I try in this notebooks?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(gs.read_command(\"g.search.modules\", flags=\"g\"))" + ] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/doc/notebooks/hydrology.ipynb b/doc/notebooks/hydrology.ipynb new file mode 100644 index 00000000000..598cf0f57eb --- /dev/null +++ b/doc/notebooks/hydrology.ipynb @@ -0,0 +1,376 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hydrology with GRASS GIS\n", + "\n", + "This is a quick introduction to common hydrologic workflows in *GRASS GIS* in *Jupyter Notebook*. In addition to common *Python* packages, it demonstrates the usage of `grass.script`, the *Python* API for GRASS GIS, and `grass.jupyter`, a *Jupyter Notebook* specific package that helps with the launch of *GRASS GIS* and with displaying maps. \n", + "\n", + "This interactive notebook is available online thanks to the [https://mybinder.org](Binder) service. To run the select part (called a *cell*), hit `Shift + Enter`.\n", + "\n", + "WHAT DOES THIS NOTEBOOK DO?\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Starting GRASS in Jupyter Notebooks" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Import Python standard library and IPython packages we need.\n", + "import os\n", + "import subprocess\n", + "import sys\n", + "\n", + "# Ask GRASS GIS where its Python packages are.\n", + "gisbase = subprocess.check_output([\"grass\", \"--config\", \"path\"], text=True).strip()\n", + "os.environ[\"GISBASE\"] = gisbase\n", + "sys.path.append(os.path.join(gisbase, \"etc\", \"python\"))\n", + "\n", + "# Import the GRASS GIS packages we need.\n", + "import grass.script as gs\n", + "import grass.jupyter as gj\n", + "\n", + "# Start GRASS Session\n", + "gj.init(\"../../../grassdata\", \"nc_basic_spm_grass7\", \"user1\")\n", + "\n", + "# Set computational region to elevation raster\n", + "gs.run_command('g.region', raster='elevation@PERMANENT', flags='pg')" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "discharge\n", + "drainage\n", + "dx\n", + "dy\n", + "flowacc\n", + "streams\n", + "water_depth\n", + "watersheds\n", + "streams\n", + "\n" + ] + } + ], + "source": [ + "# Let's see what is in the example database so we can continue to experiment\n", + "print(gs.read_command(\"g.list\", type=\"all\", mapset=\"user1\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Computing Watersheds, Drainage Direction, Flow Accumulation, and Streams\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# First, let's view the elevation raster to get an overview of the area\n", + "\n", + "# Start a GrassRenderer map\n", + "# GrassRenderer makes non-interactive maps using a PNG image\n", + "r = gj.GrassRenderer()\n", + "\n", + "# Add a raster and vector to the map\n", + "gs.run_command('r.colors', map='elevation@PERMANENT', color='elevation')\n", + "r.d_rast(map='elevation@PERMANENT')\n", + "r.d_legend(raster=\"elevation@PERMANENT\", at=(65, 90, 85, 90), fontsize=12, flags=\"b\", title='DTM')\n", + "\n", + "# Display map\n", + "r.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the elevation raster, we compute the watersheds and display the results." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute watersheds, drainage direction, flow accumulation, and streams\n", + "\n", + "# r.watershed computes all of these\n", + "gs.run_command('r.watershed', \n", + " elevation='elevation@PERMANENT',\n", + " drainage='drainage', # Drainage Direction\n", + " accumulation='flowacc', # Flow Accumulation\n", + " basin='watersheds',\n", + " stream='streams',\n", + " threshold=100000)\n", + "\n", + "# Convert streams raster to vector\n", + "gs.run_command('r.to.vect', input='streams', output='streams', type='line')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To view the results of 'r.watersheds', we'll use `grass.jupyter`'s `InteractiveMap` class which allows us to toggle between layers and zoom." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'n=228500 s=215000 w=630000 e=645000 rows=1350 cols=1500\\n'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#gs.raster_info('drainage')\n", + "gs.read_command('r.proj', flags='g',\n", + " input='drainage@user1',\n", + " dbase='../../../grassdata',\n", + " location='nc_basic_spm_grass7',\n", + " env=os.environ.copy())" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR: Raster map not found\n" + ] + }, + { + "ename": "CalledModuleError", + "evalue": "Module run `r.proj -g input=drainage@user1 dbase=../../../grassdata location=nc_basic_spm_grass7` ended with an error.\nThe subprocess ended with a non-zero return code: 1. See errors above the traceback or in the error output.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mCalledModuleError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'elevation@PERMANENT'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'drainage'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'flowacc'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'watersheds'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/grass80/etc/python/grass/jupyter/interact_display.py\u001b[0m in \u001b[0;36madd_raster\u001b[0;34m(self, name, opacity)\u001b[0m\n\u001b[1;32m 147\u001b[0m \u001b[0;31m# Reproject raster into WGS84/epsg3857 location\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0menv_info\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgisenv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_src_env\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 149\u001b[0;31m resolution = estimate_resolution(\n\u001b[0m\u001b[1;32m 150\u001b[0m \u001b[0mraster\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfull_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0mdbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0menv_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"GISDBASE\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/grass80/etc/python/grass/jupyter/utils.py\u001b[0m in \u001b[0;36mestimate_resolution\u001b[0;34m(raster, dbase, location, env)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0menvironment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 84\u001b[0m \"\"\"\n\u001b[0;32m---> 85\u001b[0;31m output = gs.read_command(\n\u001b[0m\u001b[1;32m 86\u001b[0m \u001b[0;34m\"r.proj\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflags\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"g\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mraster\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdbase\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlocation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 87\u001b[0m ).strip()\n", + "\u001b[0;32m/usr/local/grass80/etc/python/grass/script/core.py\u001b[0m in \u001b[0;36mread_command\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 608\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m_capture_stderr\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mreturncode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 610\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mhandle_errors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstdout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 611\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/grass80/etc/python/grass/script/core.py\u001b[0m in \u001b[0;36mhandle_errors\u001b[0;34m(returncode, result, args, kwargs)\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 427\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_module_and_code\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 428\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mCalledModuleError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturncode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 429\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mCalledModuleError\u001b[0m: Module run `r.proj -g input=drainage@user1 dbase=../../../grassdata location=nc_basic_spm_grass7` ended with an error.\nThe subprocess ended with a non-zero return code: 1. See errors above the traceback or in the error output." + ] + } + ], + "source": [ + "m = gj.InteractiveMap(height=400, width=600)\n", + "\n", + "m.add_raster('elevation@PERMANENT')\n", + "m.add_raster('drainage')\n", + "m.add_raster('flowacc')\n", + "m.add_raster('watersheds')\n", + "m.add_vector('streams')\n", + "\n", + "m.add_layer_control()\n", + "\n", + "m.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Watershed Area\n", + "\n", + "With our watersheds, we can copute some zonal statistics. In this section, we use the \"count\" method in `r.stats.zonal` to make a map of watershed area." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Count cells in each watershed\n", + "gs.run_command('r.stats.zonal', base='watersheds', cover='elevation', method='count', output='watersheds_count')\n", + "\n", + "# Get projection resolution\n", + "proj=gs.parse_command('g.region', flags='m')\n", + "\n", + "# Multiply N-S resollution by E-W resolution to get cell area\n", + "cell_area = float(proj['nsres'])*float(proj['ewres'])\n", + "\n", + "# Calculate watersheds areas and convert from m2 to km2\n", + "gs.mapcalc(\"'watershed_area' = float('watersheds_count'*{})/1000000\".format(cell_area))\n", + "\n", + "# Display a map of watershed areas. We'll use GrassRenderer here\n", + "gs.run_command('r.colors', map='watershed_area', color='plasma')\n", + "\n", + "watershed_map = gj.GrassRenderer()\n", + "watershed_map.d_rast(map=\"watershed_area\")\n", + "watershed_map.d_legend(raster='watershed_area',\n", + " bgcolor='none',\n", + " color='white',\n", + " border_color='none',\n", + " at=(3, 40, 84, 88),\n", + " lines=2,\n", + " fontsize=15,\n", + " title='Area',\n", + " units=' km2')\n", + "watershed_map.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Estimating Inundation using HAND\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# We need to install the r.stream.distance addon for this\n", + "gs.run_command('g.extension', extension='r.stream.distance')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modeling Surface Water Flow\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "gs.run_command('r.slope.aspect', elevation='elevation', dx='dx', dy='dy')\n", + "\n", + "gs.run_command('r.sim.water',\n", + " elevation='elevation',\n", + " dx='dx',\n", + " dy='dy',\n", + " rain_value=50,\n", + " infil_value=0,\n", + " man_value=0.05,\n", + " depth='water_depth',\n", + " discharge='discharge',\n", + " nwalkers=80000,\n", + " niterations=30)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "ERROR: Raster map not found\n" + ] + }, + { + "ename": "CalledModuleError", + "evalue": "Module run `r.proj -g input=water_depth@user1 dbase=../../../grassdata location=nc_basic_spm_grass7` ended with an error.\nThe subprocess ended with a non-zero return code: 1. See errors above the traceback or in the error output.", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mCalledModuleError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mInteractiveMap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mheight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m400\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwidth\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m600\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'water_depth'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/grass80/etc/python/grass/jupyter/interact_display.py\u001b[0m in \u001b[0;36madd_raster\u001b[0;34m(self, name, opacity)\u001b[0m\n\u001b[1;32m 147\u001b[0m \u001b[0;31m# Reproject raster into WGS84/epsg3857 location\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0menv_info\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgisenv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_src_env\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 149\u001b[0;31m resolution = estimate_resolution(\n\u001b[0m\u001b[1;32m 150\u001b[0m \u001b[0mraster\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfull_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0mdbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0menv_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"GISDBASE\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/grass80/etc/python/grass/jupyter/utils.py\u001b[0m in \u001b[0;36mestimate_resolution\u001b[0;34m(raster, dbase, location, env)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0menvironment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 84\u001b[0m \"\"\"\n\u001b[0;32m---> 85\u001b[0;31m output = gs.read_command(\n\u001b[0m\u001b[1;32m 86\u001b[0m \u001b[0;34m\"r.proj\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflags\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"g\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mraster\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdbase\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlocation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 87\u001b[0m ).strip()\n", + "\u001b[0;32m/usr/local/grass80/etc/python/grass/script/core.py\u001b[0m in \u001b[0;36mread_command\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 608\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m_capture_stderr\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mreturncode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 610\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mhandle_errors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstdout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 611\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/grass80/etc/python/grass/script/core.py\u001b[0m in \u001b[0;36mhandle_errors\u001b[0;34m(returncode, result, args, kwargs)\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 427\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_module_and_code\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 428\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mCalledModuleError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturncode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 429\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mCalledModuleError\u001b[0m: Module run `r.proj -g input=water_depth@user1 dbase=../../../grassdata location=nc_basic_spm_grass7` ended with an error.\nThe subprocess ended with a non-zero return code: 1. See errors above the traceback or in the error output." + ] + } + ], + "source": [ + "m = gj.InteractiveMap(height=400, width=600)\n", + "\n", + "m.add_raster('water_depth')\n", + "\n", + "m.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 75d38d1319becf5c5dc56a2012796d511cfee00d Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 12 Aug 2021 12:11:06 -0400 Subject: [PATCH 02/45] Deleted unnecessary cells --- doc/notebooks/hydrology.ipynb | 49 ++--------------------------------- 1 file changed, 2 insertions(+), 47 deletions(-) diff --git a/doc/notebooks/hydrology.ipynb b/doc/notebooks/hydrology.ipynb index 598cf0f57eb..88ecabf6986 100644 --- a/doc/notebooks/hydrology.ipynb +++ b/doc/notebooks/hydrology.ipynb @@ -49,30 +49,10 @@ ] }, { - "cell_type": "code", - "execution_count": 17, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "discharge\n", - "drainage\n", - "dx\n", - "dy\n", - "flowacc\n", - "streams\n", - "water_depth\n", - "watersheds\n", - "streams\n", - "\n" - ] - } - ], "source": [ - "# Let's see what is in the example database so we can continue to experiment\n", - "print(gs.read_command(\"g.list\", type=\"all\", mapset=\"user1\"))" + "## Depression Filling?" ] }, { @@ -150,31 +130,6 @@ "To view the results of 'r.watersheds', we'll use `grass.jupyter`'s `InteractiveMap` class which allows us to toggle between layers and zoom." ] }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'n=228500 s=215000 w=630000 e=645000 rows=1350 cols=1500\\n'" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#gs.raster_info('drainage')\n", - "gs.read_command('r.proj', flags='g',\n", - " input='drainage@user1',\n", - " dbase='../../../grassdata',\n", - " location='nc_basic_spm_grass7',\n", - " env=os.environ.copy())" - ] - }, { "cell_type": "code", "execution_count": 13, From b3f12ec5d115418b5ad25ec6afc0a7a841743159 Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 12 Aug 2021 12:15:45 -0400 Subject: [PATCH 03/45] deleted the notebooks I accidentally added --- .../example_notebook_grass_jupyter.ipynb | 179 ---------- doc/notebooks/hydrology.ipynb | 331 ------------------ 2 files changed, 510 deletions(-) delete mode 100644 doc/notebooks/example_notebook_grass_jupyter.ipynb delete mode 100644 doc/notebooks/hydrology.ipynb diff --git a/doc/notebooks/example_notebook_grass_jupyter.ipynb b/doc/notebooks/example_notebook_grass_jupyter.ipynb deleted file mode 100644 index fb6fdf68e0b..00000000000 --- a/doc/notebooks/example_notebook_grass_jupyter.ipynb +++ /dev/null @@ -1,179 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Try GRASS GIS in Jupyter Notebook with Python and grass.jupyter\n", - "\n", - "[\"GRASS](https://grass.osgeo.org/)\n", - "\n", - "This is a quick introduction to *GRASS GIS* in a *Jupyter Notebook* using the `grass.jupyter` package and the *Python* scripting language. The `grass.jupyter` package shortens the launch of *GRASS GIS* in *Jupyter Notebook* and provides several useful classes for creating, displaying and saving *GRASS GIS* maps. This notebook can be directly compared with `example_notebook.ipynb` to see how the package improves the integration of *GRASS GIS* and *Jupyter Notebooks*.\n", - "\n", - "\n", - "The `grass.jupyter` package was written as part of Google Summer of Code in 2021. For more information, visit the [wiki page](https://trac.osgeo.org/grass/wiki/GSoC/2021/JupyterAndGRASS).\n", - "\n", - "\n", - "Examples here are using a sample GRASS GIS dataset for North Carolina, USA. The dataset is included in this environment.\n", - "\n", - "## Usage\n", - "\n", - "To run the selected part which is called a cell, hit `Shift + Enter`.\n", - "\n", - "## Start\n", - "\n", - "There are several ways to use GRASS GIS. When using Python in a notebook, we usually find GRASS GIS Python packages first, import them, initialize GRASS GIS session, and set several variables useful for using GRASS GIS in a notebook." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Import Python standard library and IPython packages we need.\n", - "import os\n", - "import subprocess\n", - "import sys\n", - "\n", - "# Ask GRASS GIS where its Python packages are.\n", - "gisbase = subprocess.check_output([\"grass\", \"--config\", \"path\"], text=True).strip()\n", - "os.environ[\"GISBASE\"] = gisbase\n", - "sys.path.append(os.path.join(gisbase, \"etc\", \"python\"))\n", - "\n", - "# Import the GRASS GIS packages we need.\n", - "import grass.script as gs\n", - "import grass.jupyter as gj\n", - "\n", - "# Start GRASS Session\n", - "gj.init(\"../../data/grassdata\", \"nc_basic_spm_grass7\", \"user1\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Raster buffer\n", - "\n", - "Set computational region and create multiple buffers in given distances\n", - "around lakes represented as raster:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "gs.parse_command('g.region', raster=\"lakes\", flags='pg')\n", - "gs.run_command('r.buffer', input=\"lakes\", output=\"lakes_buff\", distances=[60, 120, 240, 500])\n", - "\n", - "# Start a GrassRenderer map\n", - "r = gj.GrassRenderer()\n", - "\n", - "# Add a raster and vector to the map\n", - "r.d_rast(map=\"lakes_buff\")\n", - "r.d_legend(raster=\"lakes_buff\", range=(2, 5), at=(80, 100, 2, 10), flags=\"b\")\n", - "\n", - "# Display map\n", - "r.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Vector buffer\n", - "\n", - "Create a negative buffer around state boundary represented as a vector.\n", - "Vector modules typically don't follow computational region,\n", - "but we set it to inform display modules about our area of interest." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "gs.run_command('v.buffer', input=\"boundary_state\", output=\"buffer\", distance=-10000)\n", - "gs.parse_command('g.region', vector=\"boundary_state\", flags='pg')\n", - "\n", - "# Start another GrassRenderer Map\n", - "m = gj.GrassRenderer()\n", - "\n", - "# Add vector layers and legend\n", - "m.d_vect(map=\"boundary_state\", fill_color=\"#5A91ED\", legend_label=\"State boundary\")\n", - "m.d_vect(map=\"buffer\", fill_color=\"#F8766D\", legend_label=\"Inner portion\")\n", - "m.d_legend_vect(at=(10, 35))\n", - "\n", - "# Display map\n", - "m.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Additional GRASS Information and Tutorials\n", - "\n", - "To find more information on what one can do with GRASS GIS APIs, check out:\n", - " \n", - " - [GRASS GIS Manual](https://grass.osgeo.org/grass-stable/manuals)\n", - " \n", - " - [GRASS Python API Manual](https://grass.osgeo.org/grass-stable/manuals/libpython)\n", - "\n", - "For more Jupyter Notebook GRASS GIS tutorials, visit:\n", - " - [Try GRASS GIS online](https://grass.osgeo.org/learn/tryonline/)\n", - "\n", - "## What else is in the sample North Carolina dataset?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(gs.read_command(\"g.list\", type=\"all\"))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## What other GRASS modules can I try in this notebooks?" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "print(gs.read_command(\"g.search.modules\", flags=\"g\"))" - ] - } - ], - "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.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/doc/notebooks/hydrology.ipynb b/doc/notebooks/hydrology.ipynb deleted file mode 100644 index 88ecabf6986..00000000000 --- a/doc/notebooks/hydrology.ipynb +++ /dev/null @@ -1,331 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Hydrology with GRASS GIS\n", - "\n", - "This is a quick introduction to common hydrologic workflows in *GRASS GIS* in *Jupyter Notebook*. In addition to common *Python* packages, it demonstrates the usage of `grass.script`, the *Python* API for GRASS GIS, and `grass.jupyter`, a *Jupyter Notebook* specific package that helps with the launch of *GRASS GIS* and with displaying maps. \n", - "\n", - "This interactive notebook is available online thanks to the [https://mybinder.org](Binder) service. To run the select part (called a *cell*), hit `Shift + Enter`.\n", - "\n", - "WHAT DOES THIS NOTEBOOK DO?\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Starting GRASS in Jupyter Notebooks" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "# Import Python standard library and IPython packages we need.\n", - "import os\n", - "import subprocess\n", - "import sys\n", - "\n", - "# Ask GRASS GIS where its Python packages are.\n", - "gisbase = subprocess.check_output([\"grass\", \"--config\", \"path\"], text=True).strip()\n", - "os.environ[\"GISBASE\"] = gisbase\n", - "sys.path.append(os.path.join(gisbase, \"etc\", \"python\"))\n", - "\n", - "# Import the GRASS GIS packages we need.\n", - "import grass.script as gs\n", - "import grass.jupyter as gj\n", - "\n", - "# Start GRASS Session\n", - "gj.init(\"../../../grassdata\", \"nc_basic_spm_grass7\", \"user1\")\n", - "\n", - "# Set computational region to elevation raster\n", - "gs.run_command('g.region', raster='elevation@PERMANENT', flags='pg')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Depression Filling?" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Computing Watersheds, Drainage Direction, Flow Accumulation, and Streams\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# First, let's view the elevation raster to get an overview of the area\n", - "\n", - "# Start a GrassRenderer map\n", - "# GrassRenderer makes non-interactive maps using a PNG image\n", - "r = gj.GrassRenderer()\n", - "\n", - "# Add a raster and vector to the map\n", - "gs.run_command('r.colors', map='elevation@PERMANENT', color='elevation')\n", - "r.d_rast(map='elevation@PERMANENT')\n", - "r.d_legend(raster=\"elevation@PERMANENT\", at=(65, 90, 85, 90), fontsize=12, flags=\"b\", title='DTM')\n", - "\n", - "# Display map\n", - "r.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "From the elevation raster, we compute the watersheds and display the results." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# Compute watersheds, drainage direction, flow accumulation, and streams\n", - "\n", - "# r.watershed computes all of these\n", - "gs.run_command('r.watershed', \n", - " elevation='elevation@PERMANENT',\n", - " drainage='drainage', # Drainage Direction\n", - " accumulation='flowacc', # Flow Accumulation\n", - " basin='watersheds',\n", - " stream='streams',\n", - " threshold=100000)\n", - "\n", - "# Convert streams raster to vector\n", - "gs.run_command('r.to.vect', input='streams', output='streams', type='line')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To view the results of 'r.watersheds', we'll use `grass.jupyter`'s `InteractiveMap` class which allows us to toggle between layers and zoom." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR: Raster map not found\n" - ] - }, - { - "ename": "CalledModuleError", - "evalue": "Module run `r.proj -g input=drainage@user1 dbase=../../../grassdata location=nc_basic_spm_grass7` ended with an error.\nThe subprocess ended with a non-zero return code: 1. See errors above the traceback or in the error output.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mCalledModuleError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'elevation@PERMANENT'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'drainage'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'flowacc'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'watersheds'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/grass80/etc/python/grass/jupyter/interact_display.py\u001b[0m in \u001b[0;36madd_raster\u001b[0;34m(self, name, opacity)\u001b[0m\n\u001b[1;32m 147\u001b[0m \u001b[0;31m# Reproject raster into WGS84/epsg3857 location\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0menv_info\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgisenv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_src_env\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 149\u001b[0;31m resolution = estimate_resolution(\n\u001b[0m\u001b[1;32m 150\u001b[0m \u001b[0mraster\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfull_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0mdbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0menv_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"GISDBASE\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/grass80/etc/python/grass/jupyter/utils.py\u001b[0m in \u001b[0;36mestimate_resolution\u001b[0;34m(raster, dbase, location, env)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0menvironment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 84\u001b[0m \"\"\"\n\u001b[0;32m---> 85\u001b[0;31m output = gs.read_command(\n\u001b[0m\u001b[1;32m 86\u001b[0m \u001b[0;34m\"r.proj\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflags\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"g\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mraster\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdbase\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlocation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 87\u001b[0m ).strip()\n", - "\u001b[0;32m/usr/local/grass80/etc/python/grass/script/core.py\u001b[0m in \u001b[0;36mread_command\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 608\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m_capture_stderr\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mreturncode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 610\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mhandle_errors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstdout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 611\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/grass80/etc/python/grass/script/core.py\u001b[0m in \u001b[0;36mhandle_errors\u001b[0;34m(returncode, result, args, kwargs)\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 427\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_module_and_code\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 428\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mCalledModuleError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturncode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 429\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mCalledModuleError\u001b[0m: Module run `r.proj -g input=drainage@user1 dbase=../../../grassdata location=nc_basic_spm_grass7` ended with an error.\nThe subprocess ended with a non-zero return code: 1. See errors above the traceback or in the error output." - ] - } - ], - "source": [ - "m = gj.InteractiveMap(height=400, width=600)\n", - "\n", - "m.add_raster('elevation@PERMANENT')\n", - "m.add_raster('drainage')\n", - "m.add_raster('flowacc')\n", - "m.add_raster('watersheds')\n", - "m.add_vector('streams')\n", - "\n", - "m.add_layer_control()\n", - "\n", - "m.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Watershed Area\n", - "\n", - "With our watersheds, we can copute some zonal statistics. In this section, we use the \"count\" method in `r.stats.zonal` to make a map of watershed area." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Count cells in each watershed\n", - "gs.run_command('r.stats.zonal', base='watersheds', cover='elevation', method='count', output='watersheds_count')\n", - "\n", - "# Get projection resolution\n", - "proj=gs.parse_command('g.region', flags='m')\n", - "\n", - "# Multiply N-S resollution by E-W resolution to get cell area\n", - "cell_area = float(proj['nsres'])*float(proj['ewres'])\n", - "\n", - "# Calculate watersheds areas and convert from m2 to km2\n", - "gs.mapcalc(\"'watershed_area' = float('watersheds_count'*{})/1000000\".format(cell_area))\n", - "\n", - "# Display a map of watershed areas. We'll use GrassRenderer here\n", - "gs.run_command('r.colors', map='watershed_area', color='plasma')\n", - "\n", - "watershed_map = gj.GrassRenderer()\n", - "watershed_map.d_rast(map=\"watershed_area\")\n", - "watershed_map.d_legend(raster='watershed_area',\n", - " bgcolor='none',\n", - " color='white',\n", - " border_color='none',\n", - " at=(3, 40, 84, 88),\n", - " lines=2,\n", - " fontsize=15,\n", - " title='Area',\n", - " units=' km2')\n", - "watershed_map.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Estimating Inundation using HAND\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# We need to install the r.stream.distance addon for this\n", - "gs.run_command('g.extension', extension='r.stream.distance')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Modeling Surface Water Flow\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "gs.run_command('r.slope.aspect', elevation='elevation', dx='dx', dy='dy')\n", - "\n", - "gs.run_command('r.sim.water',\n", - " elevation='elevation',\n", - " dx='dx',\n", - " dy='dy',\n", - " rain_value=50,\n", - " infil_value=0,\n", - " man_value=0.05,\n", - " depth='water_depth',\n", - " discharge='discharge',\n", - " nwalkers=80000,\n", - " niterations=30)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "ERROR: Raster map not found\n" - ] - }, - { - "ename": "CalledModuleError", - "evalue": "Module run `r.proj -g input=water_depth@user1 dbase=../../../grassdata location=nc_basic_spm_grass7` ended with an error.\nThe subprocess ended with a non-zero return code: 1. See errors above the traceback or in the error output.", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mCalledModuleError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mm\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mInteractiveMap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mheight\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m400\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwidth\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m600\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_raster\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'water_depth'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/grass80/etc/python/grass/jupyter/interact_display.py\u001b[0m in \u001b[0;36madd_raster\u001b[0;34m(self, name, opacity)\u001b[0m\n\u001b[1;32m 147\u001b[0m \u001b[0;31m# Reproject raster into WGS84/epsg3857 location\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0menv_info\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgisenv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_src_env\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 149\u001b[0;31m resolution = estimate_resolution(\n\u001b[0m\u001b[1;32m 150\u001b[0m \u001b[0mraster\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfull_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0mdbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0menv_info\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"GISDBASE\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/grass80/etc/python/grass/jupyter/utils.py\u001b[0m in \u001b[0;36mestimate_resolution\u001b[0;34m(raster, dbase, location, env)\u001b[0m\n\u001b[1;32m 83\u001b[0m \u001b[0menvironment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 84\u001b[0m \"\"\"\n\u001b[0;32m---> 85\u001b[0;31m output = gs.read_command(\n\u001b[0m\u001b[1;32m 86\u001b[0m \u001b[0;34m\"r.proj\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mflags\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"g\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mraster\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdbase\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdbase\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlocation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlocation\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0menv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 87\u001b[0m ).strip()\n", - "\u001b[0;32m/usr/local/grass80/etc/python/grass/script/core.py\u001b[0m in \u001b[0;36mread_command\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 608\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m_capture_stderr\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mreturncode\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 609\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstderr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 610\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mhandle_errors\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstdout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 611\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 612\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/grass80/etc/python/grass/script/core.py\u001b[0m in \u001b[0;36mhandle_errors\u001b[0;34m(returncode, result, args, kwargs)\u001b[0m\n\u001b[1;32m 426\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 427\u001b[0m \u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_module_and_code\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 428\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mCalledModuleError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmodule\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreturncode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mreturncode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 429\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 430\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mCalledModuleError\u001b[0m: Module run `r.proj -g input=water_depth@user1 dbase=../../../grassdata location=nc_basic_spm_grass7` ended with an error.\nThe subprocess ended with a non-zero return code: 1. See errors above the traceback or in the error output." - ] - } - ], - "source": [ - "m = gj.InteractiveMap(height=400, width=600)\n", - "\n", - "m.add_raster('water_depth')\n", - "\n", - "m.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "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.8.10" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} From dee037784e60e26cc1fda46368bda1ba73d5b417 Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 9 Dec 2021 13:14:04 -0500 Subject: [PATCH 04/45] Initial Commit --- python/grass/jupyter/timeseries.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 python/grass/jupyter/timeseries.py diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py new file mode 100644 index 00000000000..e69de29bb2d From 9756bbeafdf464ad3c162c6e31f9503cf175a22f Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 9 Dec 2021 13:15:34 -0500 Subject: [PATCH 05/45] Update Makefile and __init__ --- python/grass/jupyter/Makefile | 3 +- python/grass/jupyter/__init__.py | 1 + python/grass/jupyter/timeseries.py | 87 ++++++++++++++++++++++++++++++ 3 files changed, 90 insertions(+), 1 deletion(-) diff --git a/python/grass/jupyter/Makefile b/python/grass/jupyter/Makefile index 9bf5c57ba77..82ba664aedd 100644 --- a/python/grass/jupyter/Makefile +++ b/python/grass/jupyter/Makefile @@ -11,7 +11,8 @@ MODULES = \ interact_display \ region \ render3d \ - utils + utils \ + timeseries PYFILES := $(patsubst %,$(DSTDIR)/%.py,$(MODULES) __init__) PYCFILES := $(patsubst %,$(DSTDIR)/%.pyc,$(MODULES) __init__) diff --git a/python/grass/jupyter/__init__.py b/python/grass/jupyter/__init__.py index 74a5af60d8a..4472016eec8 100644 --- a/python/grass/jupyter/__init__.py +++ b/python/grass/jupyter/__init__.py @@ -26,3 +26,4 @@ from .render3d import * from .setup import * from .utils import * +from .timeseries import * diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index e69de29bb2d..4b0a3b6b394 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -0,0 +1,87 @@ +# MODULE: grass.jupyter.timeseries +# +# AUTHOR(S): Caitlin Haedrich +# +# PURPOSE: This module contains functions visualizing time-space raster +# and vector datasets in Jupyter Notebooks +# +# COPYRIGHT: (C) 2021 Caitlin Haedrich, and by the GRASS Development Team +# +# This program is free software under the GNU General Public +# License (>=v2). Read the file COPYING that comes with GRASS +# for details. + +import tempfile +import grass.script as gs + +from .region import RegionManagerFor2D, RegionManagerFor3D +import ipywidgets as widgets + + +class timeseries: + """timeseries creates visualization of time-space raster and + vector dataset in Jupyter Notebooks""" + + def __init__(self, map, basemap, overlay): + self.map = map + self.basemap = basemap + self.overlay = overlay + # Check that map ends with tsrds or tsvds + + # self.type == type #tsrds or tsvds + + def render_layers(self): + if self.type == "tsrds": + lyrList = gs.read_command("t.rast.list", input=self.map) + if self.type == "tsvds": + lyrList = gs.read_command("t.vect.list", input=self.map) + + lyrList = str(lyrList) + lyrList = lyrList.split("\r\n") + + names = [] + for line in lyrList[1:-1]: + line = line.split("|") + names.append(line[0]) + + # TODO: add tempdirectory here for filenames + filenames = [] + for name in names: + filename = "{}.png".format(name) + filenames.append(filename) + img = gj.GrassRenderer(filename=filename) + if self.background: + img.d_rast(map=self.background) + if self.type == "tsrds": + img.d_rast(map=name) + if self.type == "tsvds": + img.d._vect(map=name) + if self.overlay: + img.d_vect(map=self.overlay) + + def timeslider(self): + + # create list of date/times for labels + dates = [] + + # Create slider + slider = widgets.SelectionSlider( + options=dates, + value=dates, + continuous_update=False, + disabled=False + ) + + output_map = widgets.Output() + + def react_with_slider(change): + output_map.clear_output(wait=True) + with output_map: + draw_map(change.new) + + slider.observe(react_with_slider, names='value') + + display(output_map) + display(slider) + + From e838124c55b676f220888f23fbc77d1aacfc7f34 Mon Sep 17 00:00:00 2001 From: Caitlin H <69856275+chaedri@users.noreply.github.com> Date: Fri, 10 Dec 2021 10:51:52 -0500 Subject: [PATCH 06/45] Apply suggestions from code review Co-authored-by: Veronica Andreo --- python/grass/jupyter/timeseries.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 4b0a3b6b394..3a68ade182b 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -2,8 +2,8 @@ # # AUTHOR(S): Caitlin Haedrich # -# PURPOSE: This module contains functions visualizing time-space raster -# and vector datasets in Jupyter Notebooks +# PURPOSE: This module contains functions for visualizing raster and vector +# space-time datasets in Jupyter Notebooks # # COPYRIGHT: (C) 2021 Caitlin Haedrich, and by the GRASS Development Team # From 91d67c903de4378fa7bb0d9f4d575025b4675c92 Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 20 Jan 2022 13:29:25 -0500 Subject: [PATCH 07/45] Renders all images to temp dir --- python/grass/jupyter/timeseries.py | 86 +++++++++++++++++++++--------- 1 file changed, 61 insertions(+), 25 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 3a68ade182b..08844ba047c 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -12,7 +12,11 @@ # for details. import tempfile +import os import grass.script as gs +from .display import GrassRenderer +#from grass.animation import temporal_manager as tm +#import grass.temporal as tgis from .region import RegionManagerFor2D, RegionManagerFor3D import ipywidgets as widgets @@ -22,42 +26,74 @@ class timeseries: """timeseries creates visualization of time-space raster and vector dataset in Jupyter Notebooks""" - def __init__(self, map, basemap, overlay): - self.map = map + def __init__(self, timeseries, type="strds", basemap=None, overlay=None): + self.timeseries = timeseries self.basemap = basemap self.overlay = overlay - # Check that map ends with tsrds or tsvds - - # self.type == type #tsrds or tsvds + self.etype = type # element type - convention from temporal manager + + # Check that map is time space dataset + #self.validateTimeseriesName() + test = gs.read_command("t.list", where=f"name LIKE '{timeseries}'") + if not test: + raise AttributeError(_(f"Could not find space time raster or vector dataset named {timeseries}")) + + # Create a temporary directory for our PNG images + self._tmpdir = tempfile.TemporaryDirectory() + print(self._tmpdir.name) + + #def d_legend(self, **kwargs): + # this function should construct a legend command that can + # be called in the render_layers loop below + + # THIS IS FROM gui/wxpython/animation/util.py but I couldn't figure out how + # to import that... + # CANNOT IMPORT grass.temporal + # def validateTimeseriesName(self): + # """Check if space time dataset exists and completes missing mapset. + # + # Raises GException if dataset doesn't exist.""" + # trastDict = tgis.tlist_grouped(self.etype) + # if self.timeseries.find("@") >= 0: + # nameShort, mapset = self.timeseries.split("@", 1) + # if nameShort in trastDict[mapset]: + # return self.timeseries + # else: + # raise GException(_(f"Space time dataset {self.timeseries} not found.")) + # + # mapsets = tgis.get_tgis_c_library_interface().available_mapsets() + # for mapset in mapsets: + # if mapset in trastDict.keys(): + # if self.timeseries in trastDict[mapset]: + # return self.timeseries + "@" + mapset + # raise GException(_(f"Space time dataset {self.timeseries} not found.")) def render_layers(self): - if self.type == "tsrds": - lyrList = gs.read_command("t.rast.list", input=self.map) - if self.type == "tsvds": - lyrList = gs.read_command("t.vect.list", input=self.map) - - lyrList = str(lyrList) - lyrList = lyrList.split("\r\n") - - names = [] - for line in lyrList[1:-1]: - line = line.split("|") - names.append(line[0]) + # NOT SURE IF THIS WILL ALWAYS WORK + # The maps key is found in the command history of the t.info output + # If, somehow, there was no "t.register" with map list in the command history, + # I think this would fail. + renderlist = gs.parse_command("t.info", input=self.timeseries, flags="h")["maps"][1:-1].split(",") - # TODO: add tempdirectory here for filenames filenames = [] - for name in names: - filename = "{}.png".format(name) + for name in renderlist: + filename= os.path.join(self._tmpdir.name, "{}.png".format(name)) filenames.append(filename) - img = gj.GrassRenderer(filename=filename) - if self.background: - img.d_rast(map=self.background) - if self.type == "tsrds": + img = GrassRenderer(filename=filename) + if self.basemap: + img.d_rast(map=self.basemap) + # THIS IS A BAD WAY OF DOING THIS + try: img.d_rast(map=name) - if self.type == "tsvds": + except CalledModuleError: img.d._vect(map=name) if self.overlay: img.d_vect(map=self.overlay) + # THIS SHOULD CHANGE WITH d_legend completion + info = gs.parse_command("t.info", input="precip_sum", flags="g") + min_min = info["min_min"] + max_max = info["max_max"] + img.d_legend(raster=name, range=f"{min_min}, {max_max}") def timeslider(self): From 2bb86af2249230fc03389c61ec30a17c52555967 Mon Sep 17 00:00:00 2001 From: chaedri Date: Mon, 24 Jan 2022 12:41:08 -0500 Subject: [PATCH 08/45] Working timeslider with dropdown menu --- python/grass/jupyter/timeseries.py | 104 ++++++++++++----------------- 1 file changed, 42 insertions(+), 62 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 08844ba047c..fcebc222631 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -13,13 +13,14 @@ import tempfile import os +import datetime import grass.script as gs from .display import GrassRenderer #from grass.animation import temporal_manager as tm #import grass.temporal as tgis from .region import RegionManagerFor2D, RegionManagerFor3D -import ipywidgets as widgets + class timeseries: @@ -30,50 +31,34 @@ def __init__(self, timeseries, type="strds", basemap=None, overlay=None): self.timeseries = timeseries self.basemap = basemap self.overlay = overlay - self.etype = type # element type - convention from temporal manager + self._legend = False + self.type = type + self._legend_kwargs = None + self._filenames = None # Check that map is time space dataset - #self.validateTimeseriesName() test = gs.read_command("t.list", where=f"name LIKE '{timeseries}'") if not test: - raise AttributeError(_(f"Could not find space time raster or vector dataset named {timeseries}")) + raise NameError(_(f"Could not find space time raster or vector dataset named {timeseries}")) + + # Check datatype # Create a temporary directory for our PNG images self._tmpdir = tempfile.TemporaryDirectory() print(self._tmpdir.name) - #def d_legend(self, **kwargs): - # this function should construct a legend command that can - # be called in the render_layers loop below - - # THIS IS FROM gui/wxpython/animation/util.py but I couldn't figure out how - # to import that... - # CANNOT IMPORT grass.temporal - # def validateTimeseriesName(self): - # """Check if space time dataset exists and completes missing mapset. - # - # Raises GException if dataset doesn't exist.""" - # trastDict = tgis.tlist_grouped(self.etype) - # if self.timeseries.find("@") >= 0: - # nameShort, mapset = self.timeseries.split("@", 1) - # if nameShort in trastDict[mapset]: - # return self.timeseries - # else: - # raise GException(_(f"Space time dataset {self.timeseries} not found.")) - # - # mapsets = tgis.get_tgis_c_library_interface().available_mapsets() - # for mapset in mapsets: - # if mapset in trastDict.keys(): - # if self.timeseries in trastDict[mapset]: - # return self.timeseries + "@" + mapset - # raise GException(_(f"Space time dataset {self.timeseries} not found.")) + def d_legend(self, **kwargs): + self._legend = True + self._legend_kwargs = kwargs + def render_layers(self): - # NOT SURE IF THIS WILL ALWAYS WORK - # The maps key is found in the command history of the t.info output - # If, somehow, there was no "t.register" with map list in the command history, - # I think this would fail. - renderlist = gs.parse_command("t.info", input=self.timeseries, flags="h")["maps"][1:-1].split(",") + if self.type == "strds": + renderlist = gs.read_command("t.rast.list", input=self.timeseries, columns="name", flags="u").strip().split("\n") + elif self.type == "stvds": + renderlist = gs.read_command("t.vect.list", input=self.timeseries, columns="name", flags="u").strip().split("\n") + else: + raise NameError(_(f"Dataset {self.timeseries} is not data type 'strds' or 'stvds'")) filenames = [] for name in renderlist: @@ -82,42 +67,37 @@ def render_layers(self): img = GrassRenderer(filename=filename) if self.basemap: img.d_rast(map=self.basemap) - # THIS IS A BAD WAY OF DOING THIS - try: + if self.type == "strds": + print(name) img.d_rast(map=name) - except CalledModuleError: - img.d._vect(map=name) + elif self.type == "stvds": + img.d_vect(map=name) if self.overlay: img.d_vect(map=self.overlay) - # THIS SHOULD CHANGE WITH d_legend completion - info = gs.parse_command("t.info", input="precip_sum", flags="g") - min_min = info["min_min"] - max_max = info["max_max"] - img.d_legend(raster=name, range=f"{min_min}, {max_max}") + # Add legend if called + if self._legend: + info = gs.parse_command("t.info", input="precip_sum", flags="g") + min_min = info["min_min"] + max_max = info["max_max"] + img.d_legend(raster=name, range=f"{min_min}, {max_max}", **self._legend_kwargs) + + self._filenames = filenames def timeslider(self): + # Lazy Imports + import ipywidgets as widgets + from IPython.display import Image # create list of date/times for labels - dates = [] - - # Create slider - slider = widgets.SelectionSlider( - options=dates, - value=dates, - continuous_update=False, - disabled=False - ) - - output_map = widgets.Output() - - def react_with_slider(change): - output_map.clear_output(wait=True) - with output_map: - draw_map(change.new) + if self.type == "strds": + dates = gs.read_command("t.rast.list", input=self.timeseries, columns="start_time", flags="u").strip().split("\n") + elif self.type == "stvds": + dates = gs.read_command("t.vect.list", input=self.timeseries, columns="start_time", flags="u").strip().split("\n") - slider.observe(react_with_slider, names='value') + value_dict = {dates[i]: self._filenames[i] for i in range(len(dates))} - display(output_map) - display(slider) + def view_image(date): + return Image(value_dict[date]) + widgets.interact(view_image, date=dates) From a402b515502ade5cc45c62f4944b8987363a3f6b Mon Sep 17 00:00:00 2001 From: chaedri Date: Mon, 24 Jan 2022 14:30:56 -0500 Subject: [PATCH 09/45] Black formatting and demo notebook --- doc/notebooks/Temporal.ipynb | 231 +++++++++++++++++++++++++++++++++++ 1 file changed, 231 insertions(+) create mode 100644 doc/notebooks/Temporal.ipynb diff --git a/doc/notebooks/Temporal.ipynb b/doc/notebooks/Temporal.ipynb new file mode 100644 index 00000000000..8050e09fa52 --- /dev/null +++ b/doc/notebooks/Temporal.ipynb @@ -0,0 +1,231 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Spatio-Temporal Analysis with grass.jupyter\n", + "\n", + "As part of a GRASS mini grant, we've been adding visualization functions for time space datasets (strds and stvds). You can find out more about the project and follow the progress on the [GRASS wiki page](https://trac.osgeo.org/grass/wiki/GSoC/2021/JupyterAndGRASS/MiniGrant2022).\n", + "\n", + "This interactive notebook is available online thanks to the [https://mybinder.org](Binder) service. To run the select part (called a *cell*), hit `Shift + Enter`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import subprocess\n", + "import sys\n", + "import shutil\n", + "\n", + "# Download zip\n", + "!curl http://fatra.cnr.ncsu.edu/temporal-grass-workshop/NC_spm_temporal_workshop.zip -o ../../data/NC_spm_temporal_workshop.zip\n", + "\n", + "# Unpack zip to grassdata\n", + "shutil.unpack_archive(\"../../data/NC_spm_temporal_workshop\", \"../../data/grassdata\", \"zip\")\n", + "\n", + "# Delete Zip\n", + "os.remove(\"../../data/NC_spm_temporal_workshop.zip\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Start GRASS GIS" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Ask GRASS GIS where its Python packages are.\n", + "sys.path.append(\n", + " subprocess.check_output([\"grass\", \"--config\", \"python_path\"], text=True).strip()\n", + ")\n", + "\n", + "# Import GRASS packages\n", + "import grass.script as gs\n", + "import grass.jupyter as gj\n", + "\n", + "# Start GRASS Session\n", + "gj.init(\"../../data/grassdata\", \"NC_spm_temporal_workshop\", \"climate_2000_2012\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set computational region to the elevation raster." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "gs.run_command(\"g.region\", raster=\"elev_state_500m\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create empty space time datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "gs.run_command('t.create', output='tempmean', type='strds',\n", + " temporaltype='absolute', title=\"Average temperature\",\n", + " description=\"Monthly temperature average in NC [deg C]\")\n", + "\n", + "gs.run_command('t.create', output='precip_sum', type='strds',\n", + " temporaltype='absolute', title=\"Preciptation\",\n", + " description=\"Monthly precipitation sums in NC [mm]\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create list of rasters to be registered to empty space time datasets" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "tempmean_list = gs.read_command(\"g.list\", type=\"raster\", pattern=\"*tempmean\", separator=\"comma\").strip()\n", + "precip_list = gs.read_command(\"g.list\", type=\"raster\", pattern=\"*precip\", separator=\"comma\").strip()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Register the rasters to the space time dataset created above" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "gs.run_command(\"t.register\",\n", + " input=\"tempmean\",\n", + " type=\"raster\",\n", + " start=\"2000-01-01\",\n", + " increment=\"1 months\", \n", + " maps=tempmean_list,\n", + " flags=\"i\")\n", + "\n", + "gs.run_command(\"t.register\",\n", + " input=\"precip_sum\",\n", + " type=\"raster\",\n", + " start=\"2000-01-01\",\n", + " increment=\"1 months\",\n", + " maps=precip_list,\n", + " flags=\"i\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Extract a small subset for visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "gs.run_command(\"t.rast.extract\",\n", + " input=\"precip_sum\",\n", + " output=\"precip_sum_2010\",\n", + " where=\"start_time >= '2010-01-01' and start_time < '2011-01-01'\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Set the color table for all rasters in timeseries" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "gs.run_command(\"t.rast.colors\", input=\"precip_sum_2010\", color=\"precipitation_monthly\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Temporal Visualizations\n", + "\n", + "The `TimeSeries` class contains visualization functions for GRASS space time dataset (strds or stvds). The `TimeSlider` function allows users to interactively view the evolution of the dataset through time using IPython and Jupyter Widgets." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "img = gj.TimeSeries(\"precip_sum_2010\")\n", + "img.d_legend(color=\"gray\") #Add legend\n", + "img.render_layers() #Render Layers (this should eventually be including in TimeSlider I think)\n", + "img.TimeSlider() #Create TimeSlider, currently a dropdown menu but I'm working towards it being a SelectionSlider" + ] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 227cad6962e4e9914f9e7ca31d8b1d7b3063468d Mon Sep 17 00:00:00 2001 From: chaedri Date: Mon, 24 Jan 2022 14:33:55 -0500 Subject: [PATCH 10/45] Black formatting --- python/grass/jupyter/timeseries.py | 74 ++++++++++++++++++++---------- 1 file changed, 51 insertions(+), 23 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index fcebc222631..df0fa207422 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -13,17 +13,11 @@ import tempfile import os -import datetime import grass.script as gs from .display import GrassRenderer -#from grass.animation import temporal_manager as tm -#import grass.temporal as tgis -from .region import RegionManagerFor2D, RegionManagerFor3D - - -class timeseries: +class TimeSeries: """timeseries creates visualization of time-space raster and vector dataset in Jupyter Notebooks""" @@ -39,36 +33,49 @@ def __init__(self, timeseries, type="strds", basemap=None, overlay=None): # Check that map is time space dataset test = gs.read_command("t.list", where=f"name LIKE '{timeseries}'") if not test: - raise NameError(_(f"Could not find space time raster or vector dataset named {timeseries}")) - - # Check datatype + raise NameError( + _( + f"Could not find space time raster or vector dataset named {timeseries}" + ) + ) # Create a temporary directory for our PNG images self._tmpdir = tempfile.TemporaryDirectory() - print(self._tmpdir.name) def d_legend(self, **kwargs): self._legend = True self._legend_kwargs = kwargs - def render_layers(self): if self.type == "strds": - renderlist = gs.read_command("t.rast.list", input=self.timeseries, columns="name", flags="u").strip().split("\n") + renderlist = ( + gs.read_command( + "t.rast.list", input=self.timeseries, columns="name", flags="u" + ) + .strip() + .split("\n") + ) elif self.type == "stvds": - renderlist = gs.read_command("t.vect.list", input=self.timeseries, columns="name", flags="u").strip().split("\n") + renderlist = ( + gs.read_command( + "t.vect.list", input=self.timeseries, columns="name", flags="u" + ) + .strip() + .split("\n") + ) else: - raise NameError(_(f"Dataset {self.timeseries} is not data type 'strds' or 'stvds'")) + raise NameError( + _(f"Dataset {self.timeseries} is not data type 'strds' or 'stvds'") + ) filenames = [] for name in renderlist: - filename= os.path.join(self._tmpdir.name, "{}.png".format(name)) + filename = os.path.join(self._tmpdir.name, "{}.png".format(name)) filenames.append(filename) img = GrassRenderer(filename=filename) if self.basemap: img.d_rast(map=self.basemap) if self.type == "strds": - print(name) img.d_rast(map=name) elif self.type == "stvds": img.d_vect(map=name) @@ -79,25 +86,46 @@ def render_layers(self): info = gs.parse_command("t.info", input="precip_sum", flags="g") min_min = info["min_min"] max_max = info["max_max"] - img.d_legend(raster=name, range=f"{min_min}, {max_max}", **self._legend_kwargs) + img.d_legend( + raster=name, range=f"{min_min}, {max_max}", **self._legend_kwargs + ) self._filenames = filenames - def timeslider(self): + def TimeSlider(self): # Lazy Imports import ipywidgets as widgets from IPython.display import Image # create list of date/times for labels if self.type == "strds": - dates = gs.read_command("t.rast.list", input=self.timeseries, columns="start_time", flags="u").strip().split("\n") + dates = ( + gs.read_command( + "t.rast.list", + input=self.timeseries, + columns="start_time", + flags="u", + ) + .strip() + .split("\n") + ) elif self.type == "stvds": - dates = gs.read_command("t.vect.list", input=self.timeseries, columns="start_time", flags="u").strip().split("\n") - + dates = ( + gs.read_command( + "t.vect.list", + input=self.timeseries, + columns="start_time", + flags="u", + ) + .strip() + .split("\n") + ) + # Dictionary of dates and associated image filename value_dict = {dates[i]: self._filenames[i] for i in range(len(dates))} def view_image(date): return Image(value_dict[date]) + # This creates a dropdown menu for dates since they are a string + # In the future, it should create a SelectionSlider instead widgets.interact(view_image, date=dates) - From 3e76d12cf572b50aebce510d15da36e86ba065de Mon Sep 17 00:00:00 2001 From: chaedri Date: Mon, 24 Jan 2022 14:57:11 -0500 Subject: [PATCH 11/45] flak8 and typo fix --- doc/notebooks/Temporal.ipynb | 2 +- python/grass/jupyter/timeseries.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/doc/notebooks/Temporal.ipynb b/doc/notebooks/Temporal.ipynb index 8050e09fa52..144f509c98d 100644 --- a/doc/notebooks/Temporal.ipynb +++ b/doc/notebooks/Temporal.ipynb @@ -33,7 +33,7 @@ "!curl http://fatra.cnr.ncsu.edu/temporal-grass-workshop/NC_spm_temporal_workshop.zip -o ../../data/NC_spm_temporal_workshop.zip\n", "\n", "# Unpack zip to grassdata\n", - "shutil.unpack_archive(\"../../data/NC_spm_temporal_workshop\", \"../../data/grassdata\", \"zip\")\n", + "shutil.unpack_archive(\"../../data/NC_spm_temporal_workshop.zip\", \"../../data/grassdata\", \"zip\")\n", "\n", "# Delete Zip\n", "os.remove(\"../../data/NC_spm_temporal_workshop.zip\")" diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index df0fa207422..3ca64262771 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -35,7 +35,8 @@ def __init__(self, timeseries, type="strds", basemap=None, overlay=None): if not test: raise NameError( _( - f"Could not find space time raster or vector dataset named {timeseries}" + f"Could not find space time raster or vector" + f"dataset named {timeseries}" ) ) From 7ef061ffcc7375f81eae25c391af80269cc603aa Mon Sep 17 00:00:00 2001 From: chaedri Date: Mon, 31 Jan 2022 13:34:31 -0500 Subject: [PATCH 12/45] TimeSlider with ipywidgets issue --- doc/notebooks/Temporal.ipynb | 18 +++++++++--------- python/grass/jupyter/timeseries.py | 18 +++++++++++++++--- 2 files changed, 24 insertions(+), 12 deletions(-) diff --git a/doc/notebooks/Temporal.ipynb b/doc/notebooks/Temporal.ipynb index 144f509c98d..862ae1b41a2 100644 --- a/doc/notebooks/Temporal.ipynb +++ b/doc/notebooks/Temporal.ipynb @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -74,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -90,7 +90,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -112,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -129,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -159,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -178,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -201,9 +201,9 @@ "outputs": [], "source": [ "img = gj.TimeSeries(\"precip_sum_2010\")\n", - "img.d_legend(color=\"gray\") #Add legend\n", + "img.d_legend(color=\"gray\", at=(10,0,30,0)) #Add legend\n", "img.render_layers() #Render Layers (this should eventually be including in TimeSlider I think)\n", - "img.TimeSlider() #Create TimeSlider, currently a dropdown menu but I'm working towards it being a SelectionSlider" + "img.TimeSlider() #Create TimeSlider" ] } ], diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 3ca64262771..c5df63a0fa5 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -121,12 +121,24 @@ def TimeSlider(self): .strip() .split("\n") ) + # Dictionary of dates and associated image filename value_dict = {dates[i]: self._filenames[i] for i in range(len(dates))} + slider = widgets.SelectionSlider( + options=dates, + value=dates[0], + description='Date/Time', + disabled=False, + continuous_update=True, + orientation='horizontal', + readout=True, + layout=widgets.Layout(width='80%') + ) + def view_image(date): return Image(value_dict[date]) - # This creates a dropdown menu for dates since they are a string - # In the future, it should create a SelectionSlider instead - widgets.interact(view_image, date=dates) + out = widgets.interact(view_image, date=slider) + + return out From 443d273ea3cead4ee50ba68663214121060df95e Mon Sep 17 00:00:00 2001 From: chaedri Date: Tue, 1 Feb 2022 12:59:37 -0500 Subject: [PATCH 13/45] Animation function, improved formatting --- doc/notebooks/Temporal.ipynb | 20 +++- python/grass/jupyter/timeseries.py | 147 +++++++++++++++++++---------- 2 files changed, 116 insertions(+), 51 deletions(-) diff --git a/doc/notebooks/Temporal.ipynb b/doc/notebooks/Temporal.ipynb index 862ae1b41a2..35cd69197e0 100644 --- a/doc/notebooks/Temporal.ipynb +++ b/doc/notebooks/Temporal.ipynb @@ -202,8 +202,24 @@ "source": [ "img = gj.TimeSeries(\"precip_sum_2010\")\n", "img.d_legend(color=\"gray\", at=(10,0,30,0)) #Add legend\n", - "img.render_layers() #Render Layers (this should eventually be including in TimeSlider I think)\n", - "img.TimeSlider() #Create TimeSlider" + "img.render_layers() #Render Layers\n", + "img.time_slider() #Create TimeSlider" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also display the TimeSeries as an animation with `animate`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "img.animate(duration=500, label=True, text_size=16, text_color=\"gray\")" ] } ], diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index c5df63a0fa5..fb2d2175eff 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -21,14 +21,16 @@ class TimeSeries: """timeseries creates visualization of time-space raster and vector dataset in Jupyter Notebooks""" - def __init__(self, timeseries, type="strds", basemap=None, overlay=None): + def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): self.timeseries = timeseries self.basemap = basemap self.overlay = overlay self._legend = False - self.type = type + self._etype = etype # element type, borrowing convention from tgis self._legend_kwargs = None - self._filenames = None + self._filenames = [] + self._file_date_dict = {} + self._date_file_dict = {} # Check that map is time space dataset test = gs.read_command("t.list", where=f"name LIKE '{timeseries}'") @@ -43,12 +45,37 @@ def __init__(self, timeseries, type="strds", basemap=None, overlay=None): # Create a temporary directory for our PNG images self._tmpdir = tempfile.TemporaryDirectory() + # create list of date/times + if self._etype == "strds": + self._dates = ( + gs.read_command( + "t.rast.list", + input=self.timeseries, + columns="start_time", + flags="u", + ) + .strip() + .split("\n") + ) + elif self._etype == "stvds": + self._dates = ( + gs.read_command( + "t.vect.list", + input=self.timeseries, + columns="start_time", + flags="u", + ) + .strip() + .split("\n") + ) + def d_legend(self, **kwargs): self._legend = True self._legend_kwargs = kwargs def render_layers(self): - if self.type == "strds": + # Create List of layers to Render + if self._etype == "strds": renderlist = ( gs.read_command( "t.rast.list", input=self.timeseries, columns="name", flags="u" @@ -56,7 +83,7 @@ def render_layers(self): .strip() .split("\n") ) - elif self.type == "stvds": + elif self._etype == "stvds": renderlist = ( gs.read_command( "t.vect.list", input=self.timeseries, columns="name", flags="u" @@ -66,19 +93,23 @@ def render_layers(self): ) else: raise NameError( - _(f"Dataset {self.timeseries} is not data type 'strds' or 'stvds'") + _(f"Dataset {self.timeseries} is not element type 'strds' or 'stvds'") ) - filenames = [] + i = 0 for name in renderlist: + # Create image file filename = os.path.join(self._tmpdir.name, "{}.png".format(name)) - filenames.append(filename) + self._filenames.append(filename) + self._file_date_dict[self._dates[i]] = filename + self._date_file_dict[filename] = self._dates[i] + # Render image img = GrassRenderer(filename=filename) if self.basemap: img.d_rast(map=self.basemap) - if self.type == "strds": + if self._etype == "strds": img.d_rast(map=name) - elif self.type == "stvds": + elif self._etype == "stvds": img.d_vect(map=name) if self.overlay: img.d_vect(map=self.overlay) @@ -90,55 +121,73 @@ def render_layers(self): img.d_legend( raster=name, range=f"{min_min}, {max_max}", **self._legend_kwargs ) + i = i + 1 - self._filenames = filenames - - def TimeSlider(self): + def time_slider(self): # Lazy Imports import ipywidgets as widgets from IPython.display import Image - # create list of date/times for labels - if self.type == "strds": - dates = ( - gs.read_command( - "t.rast.list", - input=self.timeseries, - columns="start_time", - flags="u", - ) - .strip() - .split("\n") - ) - elif self.type == "stvds": - dates = ( - gs.read_command( - "t.vect.list", - input=self.timeseries, - columns="start_time", - flags="u", - ) - .strip() - .split("\n") - ) - - # Dictionary of dates and associated image filename - value_dict = {dates[i]: self._filenames[i] for i in range(len(dates))} - slider = widgets.SelectionSlider( - options=dates, - value=dates[0], - description='Date/Time', + options=self._dates, + value=self._dates[0], + description="Date/Time", disabled=False, continuous_update=True, - orientation='horizontal', + orientation="horizontal", readout=True, - layout=widgets.Layout(width='80%') + layout=widgets.Layout(width="80%"), ) def view_image(date): - return Image(value_dict[date]) - - out = widgets.interact(view_image, date=slider) + return Image(self._file_date_dict[date]) + + widgets.interact(view_image, date=slider) + + def animate( + self, + duration=500, + label=True, + font="DejaVuSans.ttf", + text_size=12, + text_color="gray", + ): + """ + param int duration: time to display each frame; milliseconds + param bool label: include date/time stamp on each frame + param str font: font file + param int text_size: size of date/time text + param str text_color: color to use for the text. See + https://pillow.readthedocs.io/en/stable/reference/ImageColor.html#color-names + for list of available color formats + """ + # Create a GIF from the PNG images + from PIL import Image + from PIL import ImageFont + from PIL import ImageDraw + from IPython.display import Image as ipyImage + + # filepath + fp_out = os.path.join(self._tmpdir.name, "image.gif") + + imgs = [] + for f in self._filenames: + date = self._date_file_dict[f] + img = Image.open(f) + draw = ImageDraw.Draw(img) + if label: + font_settings = ImageFont.truetype(font, text_size) + draw.text((0, 0), date, fill=text_color, font=font_settings) + imgs.append(img) + + img.save( + fp=fp_out, + format="GIF", + append_images=imgs[:-1], + save_all=True, + duration=duration, + loop=0, + ) - return out + # Display the GIF + return ipyImage(fp_out) From 04abd6a84aa70b211f002d352831591d503f68cc Mon Sep 17 00:00:00 2001 From: chaedri Date: Tue, 1 Feb 2022 16:06:28 -0500 Subject: [PATCH 14/45] Typo Fix --- doc/notebooks/Temporal.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/notebooks/Temporal.ipynb b/doc/notebooks/Temporal.ipynb index 35cd69197e0..9fe4fe668fa 100644 --- a/doc/notebooks/Temporal.ipynb +++ b/doc/notebooks/Temporal.ipynb @@ -191,7 +191,7 @@ "source": [ "## Temporal Visualizations\n", "\n", - "The `TimeSeries` class contains visualization functions for GRASS space time dataset (strds or stvds). The `TimeSlider` function allows users to interactively view the evolution of the dataset through time using IPython and Jupyter Widgets." + "The `TimeSeries` class contains visualization functions for GRASS space time dataset (strds or stvds). The `time_slider` function allows users to interactively view the evolution of the dataset through time using IPython and Jupyter Widgets." ] }, { From 48b2b0ae3d46b49f96b59ce315342ccf8efa666b Mon Sep 17 00:00:00 2001 From: chaedri Date: Tue, 8 Feb 2022 18:28:34 -0500 Subject: [PATCH 15/45] docstrings, string parsing and minor edits --- python/grass/jupyter/timeseries.py | 81 +++++++++++++++++++++++------- 1 file changed, 63 insertions(+), 18 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index fb2d2175eff..0e1bc24a8ec 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -13,18 +13,43 @@ import tempfile import os +import platform import grass.script as gs from .display import GrassRenderer +# Probably needs a better name +def parse_csv_str(string): + if platform.system() == "Windows": + out = string.strip().split("\r\n") + else: + out = string.strip().split("\n") + return out + class TimeSeries: - """timeseries creates visualization of time-space raster and - vector dataset in Jupyter Notebooks""" + """Creates visualizations of time-space raster and + vector datasets in Jupyter Notebooks + + Basic usage:: + >>> img = TimeSeries("series_name") + >>> img.d_legend() #Add legend + >>> img.render_layers() #Render Layers + >>> img.time_slider() #Create TimeSlider + >>> img.animate() + + This class of grass.jupyter is experimental and under development. + The API can change at anytime. + """ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): + """Creates an instance of the TimeSeries visualizations class. + + :param str timeseries: name of space-time dataset + :param str etype: element type, strds (space-time raster dataset) or stvds (space-time vector dataset) + :param str basemap: name of raster to use as basemap/background for visuals + :param str overlay: name of vector to add to visuals + """ self.timeseries = timeseries - self.basemap = basemap - self.overlay = overlay self._legend = False self._etype = etype # element type, borrowing convention from tgis self._legend_kwargs = None @@ -32,6 +57,13 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): self._file_date_dict = {} self._date_file_dict = {} + # TODO: Improve basemap and overlay method + # Currently does not support multiple basemaps or overlays + # (i.e. if you wanted to have two vectors rendered, like + # roads and streams, this isn't possible - you can only have one + self.basemap = basemap + self.overlay = overlay + # Check that map is time space dataset test = gs.read_command("t.list", where=f"name LIKE '{timeseries}'") if not test: @@ -47,55 +79,58 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): # create list of date/times if self._etype == "strds": - self._dates = ( + self._dates = parse_csv_str( gs.read_command( "t.rast.list", input=self.timeseries, columns="start_time", flags="u", ) - .strip() - .split("\n") ) elif self._etype == "stvds": - self._dates = ( + self._dates = parse_csv_str( gs.read_command( "t.vect.list", input=self.timeseries, columns="start_time", flags="u", ) - .strip() - .split("\n") ) def d_legend(self, **kwargs): + """Wrapper for d.legend. Passes keyword arguments to d.legend in + render_layers method. + """ self._legend = True self._legend_kwargs = kwargs def render_layers(self): + """Renders map for each time-step in space-time dataset and save to PNG + image in temporary directory. + + Must be run before creating a visualization (i.e. time_slider or animate). + + Can be time-consuming to run with large space-time datasets. + """ # Create List of layers to Render if self._etype == "strds": - renderlist = ( + renderlist = parse_csv_str( gs.read_command( "t.rast.list", input=self.timeseries, columns="name", flags="u" ) - .strip() - .split("\n") ) elif self._etype == "stvds": - renderlist = ( + renderlist = parse_csv_str( gs.read_command( "t.vect.list", input=self.timeseries, columns="name", flags="u" ) - .strip() - .split("\n") ) else: raise NameError( _(f"Dataset {self.timeseries} is not element type 'strds' or 'stvds'") ) + # Start counter for matching datetime stamp with filename i = 0 for name in renderlist: # Create image file @@ -121,13 +156,21 @@ def render_layers(self): img.d_legend( raster=name, range=f"{min_min}, {max_max}", **self._legend_kwargs ) + # Add 1 to counter i = i + 1 - def time_slider(self): + def time_slider(self, slider_width="60%"): + """ + Create interactive timeline slider. + + param str slider_width: width of datetime selection slider as a + percentage (%) or pixels (px) + """ # Lazy Imports import ipywidgets as widgets from IPython.display import Image + # Datetime selection slider slider = widgets.SelectionSlider( options=self._dates, value=self._dates[0], @@ -136,12 +179,14 @@ def time_slider(self): continuous_update=True, orientation="horizontal", readout=True, - layout=widgets.Layout(width="80%"), + layout=widgets.Layout(width=slider_width), ) + # Display image associated with datetime def view_image(date): return Image(self._file_date_dict[date]) + # Return interact widget with image and slider widgets.interact(view_image, date=slider) def animate( From 04216ea71774e1eaf11d155a942a836da2fbe887 Mon Sep 17 00:00:00 2001 From: chaedri Date: Tue, 8 Feb 2022 18:32:32 -0500 Subject: [PATCH 16/45] update string parsing function --- python/grass/jupyter/timeseries.py | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 0e1bc24a8ec..edc28de4836 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -13,17 +13,13 @@ import tempfile import os -import platform import grass.script as gs from .display import GrassRenderer + # Probably needs a better name def parse_csv_str(string): - if platform.system() == "Windows": - out = string.strip().split("\r\n") - else: - out = string.strip().split("\n") - return out + return string.strip().splitlines() class TimeSeries: From 4618cb4823a707b800e6b9f5e1ba24ab31d90db1 Mon Sep 17 00:00:00 2001 From: chaedri Date: Tue, 8 Feb 2022 21:23:45 -0500 Subject: [PATCH 17/45] flake8 formatting --- python/grass/jupyter/timeseries.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index edc28de4836..dcecaa0867a 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -41,7 +41,8 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): """Creates an instance of the TimeSeries visualizations class. :param str timeseries: name of space-time dataset - :param str etype: element type, strds (space-time raster dataset) or stvds (space-time vector dataset) + :param str etype: element type, strds (space-time raster dataset) + or stvds (space-time vector dataset) :param str basemap: name of raster to use as basemap/background for visuals :param str overlay: name of vector to add to visuals """ From 48d0bb3cb91f1808d100f81fc3a2705237e4bec3 Mon Sep 17 00:00:00 2001 From: chaedri Date: Sun, 13 Feb 2022 12:41:35 -0500 Subject: [PATCH 18/45] Manage variable time-step datasets --- python/grass/jupyter/timeseries.py | 131 ++++++++++++++++------------- 1 file changed, 73 insertions(+), 58 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index dcecaa0867a..4fd827a7563 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -17,9 +17,56 @@ from .display import GrassRenderer -# Probably needs a better name -def parse_csv_str(string): - return string.strip().splitlines() +def collect_lyr_dates(timeseries, etype): + """Create lists of layer names and start_times for a + space-time raster or vector dataset. + + For datasets with variable timesteps, makes step regular with + "gran" method for t.rast.list or t.vect.list then fills in + missing layers with previous timestep layer. If first time step + is missing, uses the first available layer. + """ + if etype == "strds": + rows = gs.read_command( + "t.rast.list", method="gran", input=timeseries + ).splitlines() + elif etype == "stvds": + rows = gs.read_command( + "t.vect.list", method="gran", input=timeseries + ).splitlines() + else: + raise NameError( + _("Dataset {} must be element type 'strds' or 'stvds'").format(timeseries) + ) + + # Parse string + new_rows = [row.split("|") for row in rows] + new_array = [list(row) for row in zip(*new_rows)] + + # Collect layer name and start time + for column in new_array: + if column[0] == "name": + names = column[1:] + if column[0] == "start_time": + dates = column[1:] + + # For variable timestep datasets, fill in None values with + # previous time step value. If first time step is missing data, + # use the next non-None value + for i, name in enumerate(names): + if name == "None": + if i > 0: + names[i] = names[i - 1] + else: + search_count = 1 + while name[i + search_count] == "None": + search_count += 1 + names[i] = name[i + 1] + else: + pass + + print(names, dates) + return names, dates class TimeSeries: @@ -49,10 +96,11 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): self.timeseries = timeseries self._legend = False self._etype = etype # element type, borrowing convention from tgis + self._renderlist = [] self._legend_kwargs = None - self._filenames = [] - self._file_date_dict = {} - self._date_file_dict = {} + # self._filenames = [] + # self._file_date_dict = {} + self._date_name_dict = {} # TODO: Improve basemap and overlay method # Currently does not support multiple basemaps or overlays @@ -62,37 +110,22 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): self.overlay = overlay # Check that map is time space dataset - test = gs.read_command("t.list", where=f"name LIKE '{timeseries}'") + test = gs.read_command("t.list", where=f"name='{timeseries}'") if not test: raise NameError( _( - f"Could not find space time raster or vector" - f"dataset named {timeseries}" - ) + "Could not find space time raster or vector " "dataset named {}" + ).format(timeseries) ) # Create a temporary directory for our PNG images self._tmpdir = tempfile.TemporaryDirectory() - # create list of date/times - if self._etype == "strds": - self._dates = parse_csv_str( - gs.read_command( - "t.rast.list", - input=self.timeseries, - columns="start_time", - flags="u", - ) - ) - elif self._etype == "stvds": - self._dates = parse_csv_str( - gs.read_command( - "t.vect.list", - input=self.timeseries, - columns="start_time", - flags="u", - ) - ) + # create list of layers to render and date/times + self._renderlist, self._dates = collect_lyr_dates(self.timeseries, self._etype) + self._date_name_dict = { + self._dates[i]: self._renderlist[i] for i in range(len(self._dates)) + } def d_legend(self, **kwargs): """Wrapper for d.legend. Passes keyword arguments to d.legend in @@ -109,32 +142,12 @@ def render_layers(self): Can be time-consuming to run with large space-time datasets. """ - # Create List of layers to Render - if self._etype == "strds": - renderlist = parse_csv_str( - gs.read_command( - "t.rast.list", input=self.timeseries, columns="name", flags="u" - ) - ) - elif self._etype == "stvds": - renderlist = parse_csv_str( - gs.read_command( - "t.vect.list", input=self.timeseries, columns="name", flags="u" - ) - ) - else: - raise NameError( - _(f"Dataset {self.timeseries} is not element type 'strds' or 'stvds'") - ) - # Start counter for matching datetime stamp with filename - i = 0 - for name in renderlist: + for name in self._renderlist: # Create image file filename = os.path.join(self._tmpdir.name, "{}.png".format(name)) - self._filenames.append(filename) - self._file_date_dict[self._dates[i]] = filename - self._date_file_dict[filename] = self._dates[i] + # self._filenames.append(filename) + # Render image img = GrassRenderer(filename=filename) if self.basemap: @@ -153,8 +166,6 @@ def render_layers(self): img.d_legend( raster=name, range=f"{min_min}, {max_max}", **self._legend_kwargs ) - # Add 1 to counter - i = i + 1 def time_slider(self, slider_width="60%"): """ @@ -181,7 +192,10 @@ def time_slider(self, slider_width="60%"): # Display image associated with datetime def view_image(date): - return Image(self._file_date_dict[date]) + # Look up raster name for date + name = self._date_name_dict[date] + filename = os.path.join(self._tmpdir.name, "{}.png".format(name)) + return Image(filename) # Return interact widget with image and slider widgets.interact(view_image, date=slider) @@ -213,9 +227,10 @@ def animate( fp_out = os.path.join(self._tmpdir.name, "image.gif") imgs = [] - for f in self._filenames: - date = self._date_file_dict[f] - img = Image.open(f) + for date in self._dates: + name = self._date_name_dict[date] + filename = os.path.join(self._tmpdir.name, "{}.png".format(name)) + img = Image.open(filename) draw = ImageDraw.Draw(img) if label: font_settings = ImageFont.truetype(font, text_size) From dbac44c22a35074cfa4a8a674f7faf90a8e08b44 Mon Sep 17 00:00:00 2001 From: chaedri Date: Sun, 13 Feb 2022 13:12:04 -0500 Subject: [PATCH 19/45] delete unnecessary print statement --- python/grass/jupyter/timeseries.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 4fd827a7563..826cb4e9b76 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -64,8 +64,6 @@ def collect_lyr_dates(timeseries, etype): names[i] = name[i + 1] else: pass - - print(names, dates) return names, dates From 2547edfee09a138ac0f4ce0c039fd9b1373175a2 Mon Sep 17 00:00:00 2001 From: chaedri Date: Sun, 13 Feb 2022 13:21:30 -0500 Subject: [PATCH 20/45] Update example for variable time-step datasets --- doc/notebooks/Temporal.ipynb | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/doc/notebooks/Temporal.ipynb b/doc/notebooks/Temporal.ipynb index 9fe4fe668fa..e499b40dd42 100644 --- a/doc/notebooks/Temporal.ipynb +++ b/doc/notebooks/Temporal.ipynb @@ -221,6 +221,35 @@ "source": [ "img.animate(duration=500, label=True, text_size=16, text_color=\"gray\")" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here is the same example but with two of the rasters unregistered, creating a dataset with variable timesteps." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gs.run_command(\"t.unregister\", type=\"raster\", input=\"precip_sum_2010\", maps=\"2010_02_precip,2010_08_precip\")\n", + "print(gs.read_command(\"t.rast.list\", input=\"precip_sum_2010\", columns=\"name,start_time\"))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "img = gj.TimeSeries(\"precip_sum_2010\")\n", + "img.d_legend(color=\"gray\", at=(10,0,30,0)) #Add legend\n", + "img.render_layers() #Render Layers\n", + "img.time_slider() #Create TimeSlider" + ] } ], "metadata": { From 896af63cde50a8630a72afcabb4b14fef6a76459 Mon Sep 17 00:00:00 2001 From: chaedri Date: Sun, 13 Feb 2022 13:24:46 -0500 Subject: [PATCH 21/45] Rename temporal notebook to match lowercase --- doc/notebooks/{Temporal.ipynb => temporal.ipynb} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename doc/notebooks/{Temporal.ipynb => temporal.ipynb} (100%) diff --git a/doc/notebooks/Temporal.ipynb b/doc/notebooks/temporal.ipynb similarity index 100% rename from doc/notebooks/Temporal.ipynb rename to doc/notebooks/temporal.ipynb From 28450a77bcc9e64f33b1ef8ab141a3a76faef34e Mon Sep 17 00:00:00 2001 From: chaedri Date: Tue, 15 Feb 2022 09:59:08 -0500 Subject: [PATCH 22/45] Rename 2nd TimeSeries instance to avoid error --- doc/notebooks/temporal.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/doc/notebooks/temporal.ipynb b/doc/notebooks/temporal.ipynb index e499b40dd42..86d538de76e 100644 --- a/doc/notebooks/temporal.ipynb +++ b/doc/notebooks/temporal.ipynb @@ -245,10 +245,10 @@ "metadata": {}, "outputs": [], "source": [ - "img = gj.TimeSeries(\"precip_sum_2010\")\n", - "img.d_legend(color=\"gray\", at=(10,0,30,0)) #Add legend\n", - "img.render_layers() #Render Layers\n", - "img.time_slider() #Create TimeSlider" + "img2 = gj.TimeSeries(\"precip_sum_2010\")\n", + "img2.d_legend(color=\"gray\", at=(10,0,30,0)) #Add legend\n", + "img2.render_layers() #Render Layers\n", + "img2.time_slider() #Create TimeSlider" ] } ], From 132bad606822a8a049ebdff58fc2eb12f86140bc Mon Sep 17 00:00:00 2001 From: chaedri Date: Fri, 18 Feb 2022 11:19:42 -0500 Subject: [PATCH 23/45] Add tempfile cleanup with weakref --- python/grass/jupyter/timeseries.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 826cb4e9b76..dbea8544718 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -13,6 +13,7 @@ import tempfile import os +import weakref import grass.script as gs from .display import GrassRenderer @@ -117,7 +118,15 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): ) # Create a temporary directory for our PNG images - self._tmpdir = tempfile.TemporaryDirectory() + self._tmpdir = ( + # pylint: disable=consider-using-with + tempfile.TemporaryDirectory() + ) + + def cleanup(tmpdir): + tmpdir.cleanup() + + weakref.finalize(self, cleanup, self._tmpdir) # create list of layers to render and date/times self._renderlist, self._dates = collect_lyr_dates(self.timeseries, self._etype) From 9535a0e4fd144c127aa0e1a809369a479314d616 Mon Sep 17 00:00:00 2001 From: chaedri Date: Fri, 18 Feb 2022 12:10:13 -0500 Subject: [PATCH 24/45] pylint, black, flake8 --- python/grass/jupyter/timeseries.py | 52 +++++++++++++++++++----------- 1 file changed, 33 insertions(+), 19 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index dbea8544718..089de5e7684 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -10,6 +10,7 @@ # This program is free software under the GNU General Public # License (>=v2). Read the file COPYING that comes with GRASS # for details. +"Create and display visualizations for space-time datasets." import tempfile import os @@ -101,10 +102,10 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): # self._file_date_dict = {} self._date_name_dict = {} - # TODO: Improve basemap and overlay method # Currently does not support multiple basemaps or overlays # (i.e. if you wanted to have two vectors rendered, like # roads and streams, this isn't possible - you can only have one + # We should be put a better method here someday self.basemap = basemap self.overlay = overlay @@ -152,7 +153,7 @@ def render_layers(self): for name in self._renderlist: # Create image file - filename = os.path.join(self._tmpdir.name, "{}.png".format(name)) + filename = os.path.join(self._tmpdir.name, f"{name}.png") # self._filenames.append(filename) # Render image @@ -182,8 +183,8 @@ def time_slider(self, slider_width="60%"): percentage (%) or pixels (px) """ # Lazy Imports - import ipywidgets as widgets - from IPython.display import Image + import ipywidgets as widgets # pylint: disable=import-outside-toplevel + from IPython.display import Image # pylint: disable=import-outside-toplevel # Datetime selection slider slider = widgets.SelectionSlider( @@ -201,7 +202,7 @@ def time_slider(self, slider_width="60%"): def view_image(date): # Look up raster name for date name = self._date_name_dict[date] - filename = os.path.join(self._tmpdir.name, "{}.png".format(name)) + filename = os.path.join(self._tmpdir.name, f"{name}.png") return Image(filename) # Return interact widget with image and slider @@ -214,38 +215,51 @@ def animate( font="DejaVuSans.ttf", text_size=12, text_color="gray", + filename=None, ): """ + Creates a GIF animation of rendered layers. + + Text color must be in a format accepted by PIL ImageColor module. For supported + formats, visit: + https://pillow.readthedocs.io/en/stable/reference/ImageColor.html#color-names + param int duration: time to display each frame; milliseconds param bool label: include date/time stamp on each frame param str font: font file param int text_size: size of date/time text - param str text_color: color to use for the text. See - https://pillow.readthedocs.io/en/stable/reference/ImageColor.html#color-names - for list of available color formats + param str text_color: color to use for the text. + param str filename: name of output GIF file """ # Create a GIF from the PNG images - from PIL import Image - from PIL import ImageFont - from PIL import ImageDraw - from IPython.display import Image as ipyImage + from PIL import Image # pylint: disable=import-outside-toplevel + from PIL import ImageFont # pylint: disable=import-outside-toplevel + from PIL import ImageDraw # pylint: disable=import-outside-toplevel + from IPython.display import ( # pylint: disable=import-outside-toplevel + Image as ipyImage, + ) # filepath - fp_out = os.path.join(self._tmpdir.name, "image.gif") + if not filename: + filename = os.path.join(self._tmpdir.name, "image.gif") imgs = [] for date in self._dates: name = self._date_name_dict[date] - filename = os.path.join(self._tmpdir.name, "{}.png".format(name)) - img = Image.open(filename) + img_path = os.path.join(self._tmpdir.name, f"{name}.png") + img = Image.open(img_path) draw = ImageDraw.Draw(img) if label: - font_settings = ImageFont.truetype(font, text_size) - draw.text((0, 0), date, fill=text_color, font=font_settings) + draw.text( + (0, 0), + date, + fill=text_color, + font=ImageFont.truetype(font, text_size), + ) imgs.append(img) img.save( - fp=fp_out, + fp=filename, format="GIF", append_images=imgs[:-1], save_all=True, @@ -254,4 +268,4 @@ def animate( ) # Display the GIF - return ipyImage(fp_out) + return ipyImage(filename) From 2cf605d5426a863861542f875d698ee7b766327b Mon Sep 17 00:00:00 2001 From: chaedri Date: Fri, 18 Feb 2022 12:16:27 -0500 Subject: [PATCH 25/45] minor docstring improvements --- python/grass/jupyter/timeseries.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 089de5e7684..fca8b4848dd 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -10,7 +10,7 @@ # This program is free software under the GNU General Public # License (>=v2). Read the file COPYING that comes with GRASS # for details. -"Create and display visualizations for space-time datasets." +"""Create and display visualizations for space-time datasets.""" import tempfile import os @@ -27,6 +27,9 @@ def collect_lyr_dates(timeseries, etype): "gran" method for t.rast.list or t.vect.list then fills in missing layers with previous timestep layer. If first time step is missing, uses the first available layer. + + :param str timeseries: name of space-time dataset + :param str etype: element type, "stvds" or "strds" """ if etype == "strds": rows = gs.read_command( @@ -70,8 +73,8 @@ def collect_lyr_dates(timeseries, etype): class TimeSeries: - """Creates visualizations of time-space raster and - vector datasets in Jupyter Notebooks + """Creates visualizations of time-space raster and vector datasets in Jupyter + Notebooks. Basic usage:: >>> img = TimeSeries("series_name") @@ -80,8 +83,8 @@ class TimeSeries: >>> img.time_slider() #Create TimeSlider >>> img.animate() - This class of grass.jupyter is experimental and under development. - The API can change at anytime. + This class of grass.jupyter is experimental and under development. The API can + change at anytime. """ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): @@ -136,8 +139,8 @@ def cleanup(tmpdir): } def d_legend(self, **kwargs): - """Wrapper for d.legend. Passes keyword arguments to d.legend in - render_layers method. + """Wrapper for d.legend. Passes keyword arguments to d.legend in render_layers + ethod. """ self._legend = True self._legend_kwargs = kwargs From b36b03b780f3a03d41f10813e08925d64ee39fc9 Mon Sep 17 00:00:00 2001 From: chaedri Date: Fri, 18 Feb 2022 13:01:33 -0500 Subject: [PATCH 26/45] black --- python/grass/jupyter/timeseries.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index fca8b4848dd..43ba17fdfe3 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -140,7 +140,7 @@ def cleanup(tmpdir): def d_legend(self, **kwargs): """Wrapper for d.legend. Passes keyword arguments to d.legend in render_layers - ethod. + ethod. """ self._legend = True self._legend_kwargs = kwargs From b55f2671d5c0862323d023e8dd00b7f76d91691a Mon Sep 17 00:00:00 2001 From: chaedri Date: Mon, 28 Feb 2022 16:31:47 -0500 Subject: [PATCH 27/45] Minor changes suggested in PR --- python/grass/jupyter/timeseries.py | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 43ba17fdfe3..7dcff976b4c 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -45,8 +45,8 @@ def collect_lyr_dates(timeseries, etype): ) # Parse string - new_rows = [row.split("|") for row in rows] - new_array = [list(row) for row in zip(*new_rows)] + new_rows = [row.split("|") for row in rows] # split row by pipe separator + new_array = [list(row) for row in zip(*new_rows)] # transpose into columns where the first value is the name of the column # Collect layer name and start time for column in new_array: @@ -122,6 +122,7 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): ) # Create a temporary directory for our PNG images + # Resource managed by weakref.finalize. self._tmpdir = ( # pylint: disable=consider-using-with tempfile.TemporaryDirectory() @@ -157,7 +158,6 @@ def render_layers(self): for name in self._renderlist: # Create image file filename = os.path.join(self._tmpdir.name, f"{name}.png") - # self._filenames.append(filename) # Render image img = GrassRenderer(filename=filename) @@ -193,7 +193,7 @@ def time_slider(self, slider_width="60%"): slider = widgets.SelectionSlider( options=self._dates, value=self._dates[0], - description="Date/Time", + description=_("Date/Time"), disabled=False, continuous_update=True, orientation="horizontal", @@ -235,12 +235,8 @@ def animate( param str filename: name of output GIF file """ # Create a GIF from the PNG images - from PIL import Image # pylint: disable=import-outside-toplevel - from PIL import ImageFont # pylint: disable=import-outside-toplevel - from PIL import ImageDraw # pylint: disable=import-outside-toplevel - from IPython.display import ( # pylint: disable=import-outside-toplevel - Image as ipyImage, - ) + import PIL # pylint: disable=import-outside-toplevel + import IPython.display # pylint: disable=import-outside-toplevel # filepath if not filename: @@ -250,25 +246,25 @@ def animate( for date in self._dates: name = self._date_name_dict[date] img_path = os.path.join(self._tmpdir.name, f"{name}.png") - img = Image.open(img_path) - draw = ImageDraw.Draw(img) + img = PIL.Image.open(img_path) + draw = PIL.ImageDraw.Draw(img) if label: draw.text( (0, 0), date, fill=text_color, - font=ImageFont.truetype(font, text_size), + font=PIL.ImageFont.truetype(font, text_size), ) imgs.append(img) - img.save( + imgs[0].save( fp=filename, format="GIF", - append_images=imgs[:-1], + append_images=imgs[1:], save_all=True, duration=duration, loop=0, ) # Display the GIF - return ipyImage(filename) + return IPython.display.Image(filename) From 320cf2798d1e91195dd661a01451afa32a346526 Mon Sep 17 00:00:00 2001 From: chaedri Date: Tue, 1 Mar 2022 15:24:35 -0500 Subject: [PATCH 28/45] Automatically call render_layers --- doc/notebooks/temporal.ipynb | 100 ++++++++++++++++++----------- python/grass/jupyter/timeseries.py | 25 ++++++-- 2 files changed, 81 insertions(+), 44 deletions(-) diff --git a/doc/notebooks/temporal.ipynb b/doc/notebooks/temporal.ipynb index 86d538de76e..e65ae9441bb 100644 --- a/doc/notebooks/temporal.ipynb +++ b/doc/notebooks/temporal.ipynb @@ -24,7 +24,6 @@ "metadata": {}, "outputs": [], "source": [ - "import os\n", "import subprocess\n", "import sys\n", "import shutil\n", @@ -33,10 +32,7 @@ "!curl http://fatra.cnr.ncsu.edu/temporal-grass-workshop/NC_spm_temporal_workshop.zip -o ../../data/NC_spm_temporal_workshop.zip\n", "\n", "# Unpack zip to grassdata\n", - "shutil.unpack_archive(\"../../data/NC_spm_temporal_workshop.zip\", \"../../data/grassdata\", \"zip\")\n", - "\n", - "# Delete Zip\n", - "os.remove(\"../../data/NC_spm_temporal_workshop.zip\")" + "shutil.unpack_archive(\"../../data/NC_spm_temporal_workshop.zip\", \"../../data/grassdata\", \"zip\")" ] }, { @@ -94,13 +90,23 @@ "metadata": {}, "outputs": [], "source": [ - "gs.run_command('t.create', output='tempmean', type='strds',\n", - " temporaltype='absolute', title=\"Average temperature\",\n", - " description=\"Monthly temperature average in NC [deg C]\")\n", + "gs.run_command(\n", + " \"t.create\",\n", + " output=\"tempmean\",\n", + " type=\"strds\",\n", + " temporaltype=\"absolute\",\n", + " title=\"Average temperature\",\n", + " description=\"Monthly temperature average in NC [deg C]\",\n", + ")\n", "\n", - "gs.run_command('t.create', output='precip_sum', type='strds',\n", - " temporaltype='absolute', title=\"Preciptation\",\n", - " description=\"Monthly precipitation sums in NC [mm]\")" + "gs.run_command(\n", + " \"t.create\",\n", + " output=\"precip_sum\",\n", + " type=\"strds\",\n", + " temporaltype=\"absolute\",\n", + " title=\"Preciptation\",\n", + " description=\"Monthly precipitation sums in NC [mm]\",\n", + ")" ] }, { @@ -116,8 +122,13 @@ "metadata": {}, "outputs": [], "source": [ - "tempmean_list = gs.read_command(\"g.list\", type=\"raster\", pattern=\"*tempmean\", separator=\"comma\").strip()\n", - "precip_list = gs.read_command(\"g.list\", type=\"raster\", pattern=\"*precip\", separator=\"comma\").strip()" + "tempmean_list = gs.read_command(\n", + " \"g.list\", type=\"raster\", pattern=\"*tempmean\", separator=\"comma\"\n", + ").strip()\n", + "\n", + "precip_list = gs.read_command(\n", + " \"g.list\", type=\"raster\", pattern=\"*precip\", separator=\"comma\"\n", + ").strip()" ] }, { @@ -133,21 +144,25 @@ "metadata": {}, "outputs": [], "source": [ - "gs.run_command(\"t.register\",\n", - " input=\"tempmean\",\n", - " type=\"raster\",\n", - " start=\"2000-01-01\",\n", - " increment=\"1 months\", \n", - " maps=tempmean_list,\n", - " flags=\"i\")\n", + "gs.run_command(\n", + " \"t.register\",\n", + " input=\"tempmean\",\n", + " type=\"raster\",\n", + " start=\"2000-01-01\",\n", + " increment=\"1 months\",\n", + " maps=tempmean_list,\n", + " flags=\"i\",\n", + ")\n", "\n", - "gs.run_command(\"t.register\",\n", - " input=\"precip_sum\",\n", - " type=\"raster\",\n", - " start=\"2000-01-01\",\n", - " increment=\"1 months\",\n", - " maps=precip_list,\n", - " flags=\"i\")" + "gs.run_command(\n", + " \"t.register\",\n", + " input=\"precip_sum\",\n", + " type=\"raster\",\n", + " start=\"2000-01-01\",\n", + " increment=\"1 months\",\n", + " maps=precip_list,\n", + " flags=\"i\",\n", + ")" ] }, { @@ -163,10 +178,12 @@ "metadata": {}, "outputs": [], "source": [ - "gs.run_command(\"t.rast.extract\",\n", - " input=\"precip_sum\",\n", - " output=\"precip_sum_2010\",\n", - " where=\"start_time >= '2010-01-01' and start_time < '2011-01-01'\")" + "gs.run_command(\n", + " \"t.rast.extract\",\n", + " input=\"precip_sum\",\n", + " output=\"precip_sum_2010\",\n", + " where=\"start_time >= '2010-01-01' and start_time < '2011-01-01'\",\n", + ")" ] }, { @@ -201,9 +218,8 @@ "outputs": [], "source": [ "img = gj.TimeSeries(\"precip_sum_2010\")\n", - "img.d_legend(color=\"gray\", at=(10,0,30,0)) #Add legend\n", - "img.render_layers() #Render Layers\n", - "img.time_slider() #Create TimeSlider" + "img.d_legend(color=\"gray\", at=(10, 0, 30, 0)) # Add legend\n", + "img.time_slider() # Create TimeSlider" ] }, { @@ -235,8 +251,15 @@ "metadata": {}, "outputs": [], "source": [ - "gs.run_command(\"t.unregister\", type=\"raster\", input=\"precip_sum_2010\", maps=\"2010_02_precip,2010_08_precip\")\n", - "print(gs.read_command(\"t.rast.list\", input=\"precip_sum_2010\", columns=\"name,start_time\"))" + "gs.run_command(\n", + " \"t.unregister\",\n", + " type=\"raster\",\n", + " input=\"precip_sum_2010\",\n", + " maps=\"2010_02_precip,2010_08_precip\",\n", + ")\n", + "print(\n", + " gs.read_command(\"t.rast.list\", input=\"precip_sum_2010\", columns=\"name,start_time\")\n", + ")" ] }, { @@ -246,9 +269,8 @@ "outputs": [], "source": [ "img2 = gj.TimeSeries(\"precip_sum_2010\")\n", - "img2.d_legend(color=\"gray\", at=(10,0,30,0)) #Add legend\n", - "img2.render_layers() #Render Layers\n", - "img2.time_slider() #Create TimeSlider" + "img2.d_legend(color=\"gray\", at=(10, 0, 30, 0)) # Add legend\n", + "img2.time_slider() # Create TimeSlider" ] } ], diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 7dcff976b4c..808b51c6412 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -45,8 +45,10 @@ def collect_lyr_dates(timeseries, etype): ) # Parse string - new_rows = [row.split("|") for row in rows] # split row by pipe separator - new_array = [list(row) for row in zip(*new_rows)] # transpose into columns where the first value is the name of the column + # Create list of list + new_rows = [row.split("|") for row in rows] + # Transpose into columns where the first value is the name of the column + new_array = [list(row) for row in zip(*new_rows)] # Collect layer name and start time for column in new_array: @@ -101,9 +103,8 @@ def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): self._etype = etype # element type, borrowing convention from tgis self._renderlist = [] self._legend_kwargs = None - # self._filenames = [] - # self._file_date_dict = {} self._date_name_dict = {} + self._render_check = False # Currently does not support multiple basemaps or overlays # (i.e. if you wanted to have two vectors rendered, like @@ -145,6 +146,8 @@ def d_legend(self, **kwargs): """ self._legend = True self._legend_kwargs = kwargs + # If d_legend has been called, we need to re-render layers + self._render_check = False def render_layers(self): """Renders map for each time-step in space-time dataset and save to PNG @@ -178,6 +181,8 @@ def render_layers(self): raster=name, range=f"{min_min}, {max_max}", **self._legend_kwargs ) + self._render_check = True + def time_slider(self, slider_width="60%"): """ Create interactive timeline slider. @@ -189,6 +194,10 @@ def time_slider(self, slider_width="60%"): import ipywidgets as widgets # pylint: disable=import-outside-toplevel from IPython.display import Image # pylint: disable=import-outside-toplevel + # Render images if they have not been already + if not self._render_check: + self.render_layers() + # Datetime selection slider slider = widgets.SelectionSlider( options=self._dates, @@ -235,9 +244,15 @@ def animate( param str filename: name of output GIF file """ # Create a GIF from the PNG images - import PIL # pylint: disable=import-outside-toplevel + import PIL.Image # pylint: disable=import-outside-toplevel + import PIL.ImageDraw # pylint: disable=import-outside-toplevel + import PIL.ImageFont # pylint: disable=import-outside-toplevel import IPython.display # pylint: disable=import-outside-toplevel + # Render images if they have not been already + if not self._render_check: + self.render_layers() + # filepath if not filename: filename = os.path.join(self._tmpdir.name, "image.gif") From b602a2ab4f0a95df5d5b1ed5f0fc68992462eb99 Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 3 Mar 2022 12:13:58 -0500 Subject: [PATCH 29/45] Added fill_gaps and set_background_color methods --- python/grass/jupyter/timeseries.py | 170 ++++++++++++++++++----------- 1 file changed, 108 insertions(+), 62 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 808b51c6412..d64d8e60d4b 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -19,23 +19,32 @@ from .display import GrassRenderer -def collect_lyr_dates(timeseries, etype): +def fill_none_values(names): + for i, name in enumerate(names): + if name == "None": + names[i] = names[i - 1] + else: + pass + return names + + +def collect_layers(timeseries, element_type, fill_gaps): """Create lists of layer names and start_times for a space-time raster or vector dataset. - For datasets with variable timesteps, makes step regular with + For datasets with variable time steps, makes step regular with "gran" method for t.rast.list or t.vect.list then fills in - missing layers with previous timestep layer. If first time step - is missing, uses the first available layer. + missing layers with previous time step layer. :param str timeseries: name of space-time dataset - :param str etype: element type, "stvds" or "strds" + :param str element_type: element type, "stvds" or "strds" + :param bool fill_gaps: fill empty time steps with data from previous step """ - if etype == "strds": + if element_type == "strds": rows = gs.read_command( "t.rast.list", method="gran", input=timeseries ).splitlines() - elif etype == "stvds": + elif element_type == "stvds": rows = gs.read_command( "t.vect.list", method="gran", input=timeseries ).splitlines() @@ -57,20 +66,11 @@ def collect_lyr_dates(timeseries, etype): if column[0] == "start_time": dates = column[1:] - # For variable timestep datasets, fill in None values with - # previous time step value. If first time step is missing data, - # use the next non-None value - for i, name in enumerate(names): - if name == "None": - if i > 0: - names[i] = names[i - 1] - else: - search_count = 1 - while name[i + search_count] == "None": - search_count += 1 - names[i] = name[i + 1] - else: - pass + # For datasets with variable time steps, fill in gaps with + # previous time step value, if fill_gaps==True. + if fill_gaps: + names = fill_none_values(names) + return names, dates @@ -81,7 +81,6 @@ class TimeSeries: Basic usage:: >>> img = TimeSeries("series_name") >>> img.d_legend() #Add legend - >>> img.render_layers() #Render Layers >>> img.time_slider() #Create TimeSlider >>> img.animate() @@ -89,24 +88,36 @@ class TimeSeries: change at anytime. """ - def __init__(self, timeseries, etype="strds", basemap=None, overlay=None): + def __init__( + self, + timeseries, + element_type="strds", + fill_gaps=False, + basemap=None, + overlay=None, + ): """Creates an instance of the TimeSeries visualizations class. :param str timeseries: name of space-time dataset - :param str etype: element type, strds (space-time raster dataset) + :param str element_type: element type, strds (space-time raster dataset) or stvds (space-time vector dataset) + :param bool fill_gaps: fill empty time steps with data from previous step :param str basemap: name of raster to use as basemap/background for visuals :param str overlay: name of vector to add to visuals """ self.timeseries = timeseries self._legend = False - self._etype = etype # element type, borrowing convention from tgis - self._renderlist = [] + self._element_type = ( + element_type # element type, borrowing convention from tgis + ) + self._fill_gaps = fill_gaps + self._render_list = [] self._legend_kwargs = None self._date_name_dict = {} - self._render_check = False + self._layers_rendered = False + self._bgcolor = "white" - # Currently does not support multiple basemaps or overlays + # Currently, this does not support multiple basemaps or overlays # (i.e. if you wanted to have two vectors rendered, like # roads and streams, this isn't possible - you can only have one # We should be put a better method here someday @@ -135,19 +146,46 @@ def cleanup(tmpdir): weakref.finalize(self, cleanup, self._tmpdir) # create list of layers to render and date/times - self._renderlist, self._dates = collect_lyr_dates(self.timeseries, self._etype) + self._render_list, self._dates = collect_layers( + self.timeseries, self._element_type, self._fill_gaps + ) self._date_name_dict = { - self._dates[i]: self._renderlist[i] for i in range(len(self._dates)) + self._dates[i]: self._render_list[i] for i in range(len(self._dates)) } + def set_background_color(self, color): + self._bgcolor = color + self._layers_rendered = False + def d_legend(self, **kwargs): """Wrapper for d.legend. Passes keyword arguments to d.legend in render_layers - ethod. + method. """ self._legend = True self._legend_kwargs = kwargs # If d_legend has been called, we need to re-render layers - self._render_check = False + self._layers_rendered = False + + def render_blank_layer(self, filename): + # Render image + img = GrassRenderer(filename=filename) + if self._element_type == "strds": + img.d_rast(map=self._render_list[0]) + elif self._element_type == "stvds": + img.d_vect(map=self._render_list[0]) + # Then clear the contents + # Ensures image is the same size/background as other images in time series + img.d_erase(bgcolor=self._bgcolor) + + if self._legend: + info = gs.parse_command("t.info", input=self.timeseries, flags="g") + min_min = info["min_min"] + max_max = info["max_max"] + img.d_legend( + raster=self._render_list[0], + range=f"{min_min}, {max_max}", + **self._legend_kwargs, + ) def render_layers(self): """Renders map for each time-step in space-time dataset and save to PNG @@ -158,30 +196,37 @@ def render_layers(self): Can be time-consuming to run with large space-time datasets. """ - for name in self._renderlist: - # Create image file - filename = os.path.join(self._tmpdir.name, f"{name}.png") - - # Render image - img = GrassRenderer(filename=filename) - if self.basemap: - img.d_rast(map=self.basemap) - if self._etype == "strds": - img.d_rast(map=name) - elif self._etype == "stvds": - img.d_vect(map=name) - if self.overlay: - img.d_vect(map=self.overlay) - # Add legend if called - if self._legend: - info = gs.parse_command("t.info", input="precip_sum", flags="g") - min_min = info["min_min"] - max_max = info["max_max"] - img.d_legend( - raster=name, range=f"{min_min}, {max_max}", **self._legend_kwargs - ) - - self._render_check = True + for name in self._render_list: + if name == "None": + filename = os.path.join(self._tmpdir.name, "None.png") + self.render_blank_layer(filename) + else: + # Create image file + filename = os.path.join(self._tmpdir.name, f"{name}.png") + + # Render image + img = GrassRenderer(filename=filename) + img.d_erase(bgcolor=self._bgcolor) + if self.basemap: + img.d_rast(map=self.basemap, bgcolor=self._bgcolor) + if self._element_type == "strds": + img.d_rast(map=name, bgcolor=self._bgcolor) + elif self._element_type == "stvds": + img.d_vect(map=name) + if self.overlay: + img.d_vect(map=self.overlay) + # Add legend if called + if self._legend: + info = gs.parse_command("t.info", input=self.timeseries, flags="g") + min_min = info["min_min"] + max_max = info["max_max"] + img.d_legend( + raster=name, + range=f"{min_min}, {max_max}", + **self._legend_kwargs, + ) + + self._layers_rendered = True def time_slider(self, slider_width="60%"): """ @@ -195,7 +240,7 @@ def time_slider(self, slider_width="60%"): from IPython.display import Image # pylint: disable=import-outside-toplevel # Render images if they have not been already - if not self._render_check: + if not self._layers_rendered: self.render_layers() # Datetime selection slider @@ -250,18 +295,19 @@ def animate( import IPython.display # pylint: disable=import-outside-toplevel # Render images if they have not been already - if not self._render_check: + if not self._layers_rendered: self.render_layers() # filepath if not filename: filename = os.path.join(self._tmpdir.name, "image.gif") - imgs = [] + images = [] for date in self._dates: name = self._date_name_dict[date] img_path = os.path.join(self._tmpdir.name, f"{name}.png") img = PIL.Image.open(img_path) + img = img.convert("RGBA", dither=None) draw = PIL.ImageDraw.Draw(img) if label: draw.text( @@ -270,12 +316,12 @@ def animate( fill=text_color, font=PIL.ImageFont.truetype(font, text_size), ) - imgs.append(img) + images.append(img) - imgs[0].save( + images[0].save( fp=filename, format="GIF", - append_images=imgs[1:], + append_images=images[1:], save_all=True, duration=duration, loop=0, From a164de7baef7bb418b68f926f24d74b8713461a3 Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 3 Mar 2022 12:18:44 -0500 Subject: [PATCH 30/45] pylint --- python/grass/jupyter/timeseries.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index d64d8e60d4b..2e9478e64d4 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -20,6 +20,7 @@ def fill_none_values(names): + """Replace `None` values in array with previous item""" for i, name in enumerate(names): if name == "None": names[i] = names[i - 1] @@ -154,6 +155,10 @@ def cleanup(tmpdir): } def set_background_color(self, color): + """Set background color of images. + + Passed to d.rast and d.erase. Either a standard color name or R:G:B triplet. + Default is White.""" self._bgcolor = color self._layers_rendered = False @@ -167,6 +172,7 @@ def d_legend(self, **kwargs): self._layers_rendered = False def render_blank_layer(self, filename): + """Write blank image for gaps in time series""" # Render image img = GrassRenderer(filename=filename) if self._element_type == "strds": From 97b5cb16d21d882e6395acd9fccfa87467aa8ae2 Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 3 Mar 2022 13:01:18 -0500 Subject: [PATCH 31/45] Pylint Fix --- .../grass/jupyter/testsuite/timeseries_test.py | 0 python/grass/jupyter/timeseries.py | 16 ++++++++-------- 2 files changed, 8 insertions(+), 8 deletions(-) create mode 100644 python/grass/jupyter/testsuite/timeseries_test.py diff --git a/python/grass/jupyter/testsuite/timeseries_test.py b/python/grass/jupyter/testsuite/timeseries_test.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 2e9478e64d4..5f19437ada3 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -107,13 +107,13 @@ def __init__( :param str overlay: name of vector to add to visuals """ self.timeseries = timeseries - self._legend = False + self._legend = {"legend": False, "kwargs": {}} self._element_type = ( element_type # element type, borrowing convention from tgis ) self._fill_gaps = fill_gaps self._render_list = [] - self._legend_kwargs = None + #self._legend_kwargs = None self._date_name_dict = {} self._layers_rendered = False self._bgcolor = "white" @@ -166,8 +166,8 @@ def d_legend(self, **kwargs): """Wrapper for d.legend. Passes keyword arguments to d.legend in render_layers method. """ - self._legend = True - self._legend_kwargs = kwargs + self._legend["legend"] = True + self._legend["kwargs"] = kwargs # If d_legend has been called, we need to re-render layers self._layers_rendered = False @@ -183,14 +183,14 @@ def render_blank_layer(self, filename): # Ensures image is the same size/background as other images in time series img.d_erase(bgcolor=self._bgcolor) - if self._legend: + if self._legend["legend"]: info = gs.parse_command("t.info", input=self.timeseries, flags="g") min_min = info["min_min"] max_max = info["max_max"] img.d_legend( raster=self._render_list[0], range=f"{min_min}, {max_max}", - **self._legend_kwargs, + **self._legend["kwargs"], ) def render_layers(self): @@ -222,14 +222,14 @@ def render_layers(self): if self.overlay: img.d_vect(map=self.overlay) # Add legend if called - if self._legend: + if self._legend["legend"]: info = gs.parse_command("t.info", input=self.timeseries, flags="g") min_min = info["min_min"] max_max = info["max_max"] img.d_legend( raster=name, range=f"{min_min}, {max_max}", - **self._legend_kwargs, + **self._legend["kwargs"], ) self._layers_rendered = True From 880cef79915f0983a0ea4198b0acad264d556002 Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 3 Mar 2022 13:05:42 -0500 Subject: [PATCH 32/45] black --- python/grass/jupyter/timeseries.py | 1 - 1 file changed, 1 deletion(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 5f19437ada3..d0ff3390204 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -113,7 +113,6 @@ def __init__( ) self._fill_gaps = fill_gaps self._render_list = [] - #self._legend_kwargs = None self._date_name_dict = {} self._layers_rendered = False self._bgcolor = "white" From 61e445bfc0e10d20778983c9ac0d5c80205147ac Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 10 Mar 2022 14:44:49 -0500 Subject: [PATCH 33/45] Improved region, baselayer and overlay handling for TimeSeries --- python/grass/jupyter/region.py | 47 +++++++ python/grass/jupyter/timeseries.py | 194 ++++++++++++++++++----------- 2 files changed, 167 insertions(+), 74 deletions(-) diff --git a/python/grass/jupyter/region.py b/python/grass/jupyter/region.py index afd198edb44..a05c8cd39d0 100644 --- a/python/grass/jupyter/region.py +++ b/python/grass/jupyter/region.py @@ -215,3 +215,50 @@ def set_region_from_command(self, env, **kwargs): env["GRASS_REGION"] = gs.region_env(raster=elev, env=env) except CalledModuleError: return + + +class RegionManagerForTimeSeries: + """Region manager for TimeSeries visualizations.""" + + def __init__(self, use_region, saved_region, env): + """Manages region during rendering. + + :param use_region: if True, use either current or provided saved region, + else derive region from rendered layers + :param saved_region: if name of saved_region is provided, + this region is then used for rendering + :param env: environment for rendering + """ + self._env = env + self._use_region = use_region + self._saved_region = saved_region + + def set_region_from_timeseries(self, timeseries): + """Sets computational region for rendering. + + This function sets the computation region from the extent of + a space-time dataset by using its bounding box and resolution. + + If user specified the name of saved region during object's initialization, + the provided region is used. If it's not specified + and use_region=True, current region is used. + """ + if self._saved_region: + self._env["GRASS_REGION"] = gs.region_env( + region=self._saved_region, env=self._env + ) + return + if self._use_region: + # use current + return + # Get extent, resolution from space time dataset + info = gs.parse_command("t.info", input=timeseries, flags="g", env=self._env) + # Set grass region from extent + self._env["GRASS_REGION"] = gs.region_env( + n=info["north"], + s=info["south"], + e=info["east"], + w=info["west"], + nsres=info["nsres_min"], + ewres=info["ewres_min"], + ) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index d0ff3390204..9af830b87c5 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -15,8 +15,11 @@ import tempfile import os import weakref +import shutil import grass.script as gs + from .display import GrassRenderer +from .region import RegionManagerForTimeSeries def fill_none_values(names): @@ -75,6 +78,34 @@ def collect_layers(timeseries, element_type, fill_gaps): return names, dates +class MethodCallCollector: + """Records lists of GRASS modules calls to hand to GrassRenderer.run(). + + Used for base layers and overlays in TimeSeries visualizations.""" + + def __init__(self): + """Create list of GRASS display module calls""" + self.calls = [] + + def __getattr__(self, name): + """Parse attribute to GRASS display module. Attribute should be in + the form 'd_module_name'. For example, 'd.rast' is called with 'd_rast'. + """ + # Check to make sure format is correct + if not name.startswith("d_"): + raise AttributeError(_("Module must begin with 'd_'")) + # Reformat string + grass_module = name.replace("_", ".") + # Assert module exists + if not shutil.which(grass_module): + raise AttributeError(_("Cannot find GRASS module {}").format(grass_module)) + + def wrapper(**kwargs): + self.calls.append((grass_module, kwargs)) + + return wrapper + + class TimeSeries: """Creates visualizations of time-space raster and vector datasets in Jupyter Notebooks. @@ -88,14 +119,17 @@ class TimeSeries: This class of grass.jupyter is experimental and under development. The API can change at anytime. """ + # pylint: disable=too-many-instance-attributes + # Need more attributes to build timeseries visuals def __init__( self, timeseries, element_type="strds", fill_gaps=False, - basemap=None, - overlay=None, + env=None, + use_region=False, + saved_region=None, ): """Creates an instance of the TimeSeries visualizations class. @@ -104,25 +138,36 @@ def __init__( or stvds (space-time vector dataset) :param bool fill_gaps: fill empty time steps with data from previous step :param str basemap: name of raster to use as basemap/background for visuals - :param str overlay: name of vector to add to visuals """ + + # Copy Environment + if env: + self._env = env.copy() + else: + self._env = os.environ.copy() + self.timeseries = timeseries - self._legend = {"legend": False, "kwargs": {}} - self._element_type = ( - element_type # element type, borrowing convention from tgis - ) + self._element_type = element_type self._fill_gaps = fill_gaps - self._render_list = [] - self._date_name_dict = {} - self._layers_rendered = False self._bgcolor = "white" + self._legend = None + self._baselayers = MethodCallCollector() + self._overlays = MethodCallCollector() + self._layers_rendered = False + + self._layers = None + self._dates = None - # Currently, this does not support multiple basemaps or overlays - # (i.e. if you wanted to have two vectors rendered, like - # roads and streams, this isn't possible - you can only have one - # We should be put a better method here someday - self.basemap = basemap - self.overlay = overlay + self._date_layer_dict = {} + self._date_filename_dict = {} + + # create list of layers to render and date/times + self._layers, self._dates = collect_layers( + self.timeseries, self._element_type, self._fill_gaps + ) + self._date_layer_dict = { + self._dates[i]: self._layers[i] for i in range(len(self._dates)) + } # Check that map is time space dataset test = gs.read_command("t.list", where=f"name='{timeseries}'") @@ -145,13 +190,21 @@ def cleanup(tmpdir): weakref.finalize(self, cleanup, self._tmpdir) - # create list of layers to render and date/times - self._render_list, self._dates = collect_layers( - self.timeseries, self._element_type, self._fill_gaps - ) - self._date_name_dict = { - self._dates[i]: self._render_list[i] for i in range(len(self._dates)) - } + # Handle Regions + region_manager = RegionManagerForTimeSeries(use_region, saved_region, self._env) + region_manager.set_region_from_timeseries(self.timeseries) + + @property + def overlay(self): + """Add overlay to TimeSeries visualization""" + self._layers_rendered = False + return self._overlays + + @property + def baselayer(self): + """Add base layer to TimeSeries visualization""" + self._layers_rendered = False + return self._baselayers def set_background_color(self, color): """Set background color of images. @@ -165,34 +218,34 @@ def d_legend(self, **kwargs): """Wrapper for d.legend. Passes keyword arguments to d.legend in render_layers method. """ - self._legend["legend"] = True - self._legend["kwargs"] = kwargs + self._legend = kwargs # If d_legend has been called, we need to re-render layers self._layers_rendered = False - def render_blank_layer(self, filename): + def _render_legend(self, img): + """Add legend to GrassRenderer instance""" + info = gs.parse_command( + "t.info", input=self.timeseries, flags="g", env=self._env + ) + min_min = info["min_min"] + max_max = info["max_max"] + img.d_legend( + raster=self._layers[0], + range=f"{min_min}, {max_max}", + **self._legend, + ) + + def _render_blank_layer(self, filename): """Write blank image for gaps in time series""" # Render image - img = GrassRenderer(filename=filename) - if self._element_type == "strds": - img.d_rast(map=self._render_list[0]) - elif self._element_type == "stvds": - img.d_vect(map=self._render_list[0]) - # Then clear the contents - # Ensures image is the same size/background as other images in time series + img = GrassRenderer(filename=filename, use_region=True, env=self._env) + # Write blank image img.d_erase(bgcolor=self._bgcolor) + # Add legend if needed + if self._legend: + self._render_legend(img) - if self._legend["legend"]: - info = gs.parse_command("t.info", input=self.timeseries, flags="g") - min_min = info["min_min"] - max_max = info["max_max"] - img.d_legend( - raster=self._render_list[0], - range=f"{min_min}, {max_max}", - **self._legend["kwargs"], - ) - - def render_layers(self): + def render(self): """Renders map for each time-step in space-time dataset and save to PNG image in temporary directory. @@ -201,36 +254,31 @@ def render_layers(self): Can be time-consuming to run with large space-time datasets. """ - for name in self._render_list: - if name == "None": + # Render each layer + for date, layer in self._date_layer_dict.items(): + if layer == "None": filename = os.path.join(self._tmpdir.name, "None.png") - self.render_blank_layer(filename) + self._date_filename_dict[date] = filename + self._render_blank_layer(filename) else: # Create image file - filename = os.path.join(self._tmpdir.name, f"{name}.png") - + filename = os.path.join(self._tmpdir.name, f"{layer}.png") + self._date_filename_dict[date] = filename # Render image - img = GrassRenderer(filename=filename) + img = GrassRenderer(filename=filename, use_region=True, env=self._env) + # Fill image background img.d_erase(bgcolor=self._bgcolor) - if self.basemap: - img.d_rast(map=self.basemap, bgcolor=self._bgcolor) + for grass_module, kwargs in self._baselayers.calls: + img.run(grass_module, **kwargs) if self._element_type == "strds": - img.d_rast(map=name, bgcolor=self._bgcolor) + img.d_rast(map=layer) elif self._element_type == "stvds": - img.d_vect(map=name) - if self.overlay: - img.d_vect(map=self.overlay) + img.d_vect(map=layer) + for grass_module, kwargs in self._overlays.calls: + img.run(grass_module, **kwargs) # Add legend if called - if self._legend["legend"]: - info = gs.parse_command("t.info", input=self.timeseries, flags="g") - min_min = info["min_min"] - max_max = info["max_max"] - img.d_legend( - raster=name, - range=f"{min_min}, {max_max}", - **self._legend["kwargs"], - ) - + if self._legend: + self._render_legend(img) self._layers_rendered = True def time_slider(self, slider_width="60%"): @@ -246,7 +294,7 @@ def time_slider(self, slider_width="60%"): # Render images if they have not been already if not self._layers_rendered: - self.render_layers() + self.render() # Datetime selection slider slider = widgets.SelectionSlider( @@ -262,9 +310,8 @@ def time_slider(self, slider_width="60%"): # Display image associated with datetime def view_image(date): - # Look up raster name for date - name = self._date_name_dict[date] - filename = os.path.join(self._tmpdir.name, f"{name}.png") + # Look up layer name for date + filename = self._date_filename_dict[date] return Image(filename) # Return interact widget with image and slider @@ -301,16 +348,15 @@ def animate( # Render images if they have not been already if not self._layers_rendered: - self.render_layers() + self.render() - # filepath + # filepath to output GIF if not filename: filename = os.path.join(self._tmpdir.name, "image.gif") images = [] for date in self._dates: - name = self._date_name_dict[date] - img_path = os.path.join(self._tmpdir.name, f"{name}.png") + img_path = self._date_filename_dict[date] img = PIL.Image.open(img_path) img = img.convert("RGBA", dither=None) draw = PIL.ImageDraw.Draw(img) From 27ec20e73bc68bdfccc0f894c1d8f4b67cfd894b Mon Sep 17 00:00:00 2001 From: chaedri Date: Thu, 10 Mar 2022 14:49:14 -0500 Subject: [PATCH 34/45] black --- python/grass/jupyter/timeseries.py | 1 + 1 file changed, 1 insertion(+) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 9af830b87c5..962fc65b8ce 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -119,6 +119,7 @@ class TimeSeries: This class of grass.jupyter is experimental and under development. The API can change at anytime. """ + # pylint: disable=too-many-instance-attributes # Need more attributes to build timeseries visuals From 0a0efb676d073688c91f678e01193b04d0a8d5a6 Mon Sep 17 00:00:00 2001 From: chaedri Date: Fri, 25 Mar 2022 11:30:13 -0400 Subject: [PATCH 35/45] Add tests for TimeSeries --- python/grass/jupyter/tests/conftest.py | 63 ++++++++++++++ python/grass/jupyter/tests/timeseries_test.py | 87 +++++++++++++++++++ python/grass/jupyter/timeseries.py | 23 +++++ 3 files changed, 173 insertions(+) create mode 100644 python/grass/jupyter/tests/conftest.py create mode 100644 python/grass/jupyter/tests/timeseries_test.py diff --git a/python/grass/jupyter/tests/conftest.py b/python/grass/jupyter/tests/conftest.py new file mode 100644 index 00000000000..ee212e142f7 --- /dev/null +++ b/python/grass/jupyter/tests/conftest.py @@ -0,0 +1,63 @@ +"""Fixture for grass.jupyter.TimeSeries test""" + +from datetime import datetime +from types import SimpleNamespace + +import pytest + +import grass.script as gs +import grass.script.setup as grass_setup + + +@pytest.fixture(scope="module") +def space_time_raster_dataset(tmp_path_factory): + """Start a session and create a raster time series + Returns object with attributes about the dataset. + """ + tmp_path = tmp_path_factory.mktemp("raster_time_series") + location = "test" + gs.core._create_location_xy(tmp_path, location) # pylint: disable=protected-access + with grass_setup.init(tmp_path / location): + gs.run_command("g.region", s=0, n=80, w=0, e=120, b=0, t=50, res=10, res3=10) + names = [f"precipitation_{i}" for i in range(1, 7)] + max_values = [550, 450, 320, 510, 300, 650] + for name, value in zip(names, max_values): + gs.mapcalc(f"{name} = rand(0, {value})", seed=1) + dataset_name = "precipitation" + gs.run_command( + "t.create", + type="strds", + temporaltype="absolute", + output=dataset_name, + title="Precipitation", + description="Random series generated for tests", + ) + dataset_file = tmp_path / "names.txt" + dataset_file.write_text("\n".join(names)) + gs.run_command( + "t.register", + type="raster", + flags="i", + input=dataset_name, + file=dataset_file, + start="2001-01-01", + increment="1 month", + ) + # unregister a map so that we can test fill_gaps + gs.run_command( + "t.unregister", + type="raster", + input=dataset_name, + maps=names[1], + ) + times = [datetime(2001, i, 1) for i in range(1, len(names) + 1)] + times.pop(1) + full_names = [f"{name}@PERMANENT" for name in names] + full_names.pop(1) + names.pop(1) + yield SimpleNamespace( + name=dataset_name, + raster_names=names, + full_raster_names=full_names, + start_times=times, + ) diff --git a/python/grass/jupyter/tests/timeseries_test.py b/python/grass/jupyter/tests/timeseries_test.py new file mode 100644 index 00000000000..f70ea71a087 --- /dev/null +++ b/python/grass/jupyter/tests/timeseries_test.py @@ -0,0 +1,87 @@ +"""Test TimeSeries functions""" + + +from pathlib import Path +import pytest + +try: + import IPython +except ImportError: + IPython = None + +try: + import ipywidgets +except ImportError: + ipywidgets = None + +import grass.jupyter as gj + + +def test_fill_none_values(): + """Test that fill_none_values replaces None with previous value in list""" + names = ["r1", "None", "r3"] + fill_names = gj.fill_none_values(names) + assert fill_names == ["r1", "r1", "r3"] + + +def test_collect_layers(space_time_raster_dataset): + """Check that collect layers returns list of layers and dates""" + names, dates = gj.collect_layers( + space_time_raster_dataset.name, fill_gaps=False, element_type="strds" + ) + # Remove the empty time step - see space_time_raster_dataset creation + names.pop(1) + dates.pop(1) + assert names == space_time_raster_dataset.raster_names + assert len(dates) == len(space_time_raster_dataset.start_times) + assert len(names) == len(dates) + + +def test_method_call_collector(): + """Check that MethodCallCollector constructs and collects GRASS calls""" + mcc = gj.MethodCallCollector() + mcc.d_rast(map="elevation") + module, kwargs = mcc.calls[0] + assert module == "d.rast" + assert kwargs["map"] == "elevation" + + +def test_default_init(space_time_raster_dataset): + """Check that TimeSeries init runs with default parameters""" + img = gj.TimeSeries(space_time_raster_dataset.name) + assert img.timeseries == space_time_raster_dataset.name + + +@pytest.mark.parametrize("fill_gaps", ["False", "True"]) +def test_render_layers(space_time_raster_dataset, fill_gaps): + """Check that layers are rendered""" + # create instance of TimeSeries + img = gj.TimeSeries(space_time_raster_dataset.name, fill_gaps=fill_gaps) + # test baselayer, overlay and d_legend here too for efficiency (rendering is + # time-intensive) + # Add first layer in space-time dataset as test baselayer + img.baselayer.d_rast(map=space_time_raster_dataset.raster_names[0]) + # test overlay with d_barscale + img.overlay.d_barscale() + # test d_legend + img.d_legend() + # Render layers + img.render() + # check files exist: MAY NEED PYLINT DISABLE for calling private attr + for ( + _date, + filename, + ) in img._date_filename_dict.items(): # pylint: disable=protected-access + assert Path(filename).is_file() + + +@pytest.mark.skipif(IPython is None, reason="IPython package not available") +@pytest.mark.skipif(ipywidgets is None, reason="ipywidgets package not available") +def test_animate_time_slider(space_time_raster_dataset): + """Test returns from animate and time_slider are correct object types""" + img = gj.TimeSeries(space_time_raster_dataset.name) + assert isinstance(img.animate(), IPython.core.display.Image) + # This doesn't work + # assert isinstance(img.time_slider(), + # (IPython.core.display.Image, + # ipywidgets.widgets.interaction.interactive)) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 962fc65b8ce..eedc9fe789f 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -16,6 +16,7 @@ import os import weakref import shutil +import json import grass.script as gs from .display import GrassRenderer @@ -44,6 +45,28 @@ def collect_layers(timeseries, element_type, fill_gaps): :param str element_type: element type, "stvds" or "strds" :param bool fill_gaps: fill empty time steps with data from previous step """ + # NEW WAY: Comment in after PR 2258 is merged + # if element_type == "strds": + # result = json.loads( + # gs.read_command( + # "t.rast.list", method="gran", input=timeseries, format="json" + # ) + # ) + # elif element_type == "stvds": + # result = json.loads( + # gs.read_command( + # "t.vect.list", method="gran", input=timeseries, format="json" + # ) + # ) + # else: + # raise NameError( + # _("Dataset {} must be element type 'strds' or 'stvds'").format(timeseries) + # ) + # + # # Get layer names and start time from json + # names = [item["name"] for item in result["data"]] + # dates = [item["start_time"] for item in result["data"]] + if element_type == "strds": rows = gs.read_command( "t.rast.list", method="gran", input=timeseries From 4fb0cac8ec8724cc18b1f729d06ca443e5c7765a Mon Sep 17 00:00:00 2001 From: chaedri Date: Fri, 25 Mar 2022 11:41:22 -0400 Subject: [PATCH 36/45] Minor changes for checks --- python/grass/jupyter/tests/timeseries_test.py | 2 +- python/grass/jupyter/testsuite/timeseries_test.py | 0 python/grass/jupyter/timeseries.py | 2 +- 3 files changed, 2 insertions(+), 2 deletions(-) delete mode 100644 python/grass/jupyter/testsuite/timeseries_test.py diff --git a/python/grass/jupyter/tests/timeseries_test.py b/python/grass/jupyter/tests/timeseries_test.py index f70ea71a087..7a80d09acab 100644 --- a/python/grass/jupyter/tests/timeseries_test.py +++ b/python/grass/jupyter/tests/timeseries_test.py @@ -67,7 +67,7 @@ def test_render_layers(space_time_raster_dataset, fill_gaps): img.d_legend() # Render layers img.render() - # check files exist: MAY NEED PYLINT DISABLE for calling private attr + # check files exist: for ( _date, filename, diff --git a/python/grass/jupyter/testsuite/timeseries_test.py b/python/grass/jupyter/testsuite/timeseries_test.py deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index eedc9fe789f..c66c716d7e8 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -16,7 +16,6 @@ import os import weakref import shutil -import json import grass.script as gs from .display import GrassRenderer @@ -46,6 +45,7 @@ def collect_layers(timeseries, element_type, fill_gaps): :param bool fill_gaps: fill empty time steps with data from previous step """ # NEW WAY: Comment in after PR 2258 is merged + # import json # if element_type == "strds": # result = json.loads( # gs.read_command( From b6fabba56513e674dcb7b4c306fb5ecb1ebe1ec6 Mon Sep 17 00:00:00 2001 From: chaedri Date: Fri, 25 Mar 2022 12:55:14 -0400 Subject: [PATCH 37/45] Faster renderering for TimeSeries --- python/grass/jupyter/display.py | 6 ++++++ python/grass/jupyter/timeseries.py | 25 ++++++++++++++++--------- 2 files changed, 22 insertions(+), 9 deletions(-) diff --git a/python/grass/jupyter/display.py b/python/grass/jupyter/display.py index 27250f0418a..a71e0892ff4 100644 --- a/python/grass/jupyter/display.py +++ b/python/grass/jupyter/display.py @@ -56,6 +56,7 @@ def __init__( renderer="cairo", use_region=False, saved_region=None, + overwrite=False, ): """Creates an instance of the GrassRenderer class. @@ -74,6 +75,8 @@ def __init__( else derive region from rendered layers :param saved_region: if name of saved_region is provided, this region is then used for rendering + :param bool overwrite: if true, clear contents of filename with d.erase + before rendering """ # Copy Environment @@ -112,6 +115,9 @@ def cleanup(tmpdir): # Set environment var for file self._env["GRASS_RENDER_FILE"] = self._filename + if filename and overwrite: + gs.run_command("d.erase", env=self._env) + # Create Temporary Legend File self._legend_file = os.path.join(self._tmpdir.name, "legend.txt") self._env["GRASS_LEGEND_FILE"] = str(self._legend_file) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index c66c716d7e8..5cf0bbeeaa0 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -261,10 +261,9 @@ def _render_legend(self, img): def _render_blank_layer(self, filename): """Write blank image for gaps in time series""" - # Render image img = GrassRenderer(filename=filename, use_region=True, env=self._env) - # Write blank image - img.d_erase(bgcolor=self._bgcolor) + for grass_module, kwargs in self._overlays.calls: + img.run(grass_module, **kwargs) # Add legend if needed if self._legend: self._render_legend(img) @@ -278,29 +277,37 @@ def render(self): Can be time-consuming to run with large space-time datasets. """ + # Make base image (background and baselayers) + base_file = os.path.join(self._tmpdir.name, "base.png") + img = GrassRenderer(filename=base_file, use_region=True, env=self._env) + # Fill image background + img.d_erase(bgcolor=self._bgcolor) + # Add baselayers + for grass_module, kwargs in self._baselayers.calls: + img.run(grass_module, **kwargs) + # Render each layer for date, layer in self._date_layer_dict.items(): if layer == "None": filename = os.path.join(self._tmpdir.name, "None.png") self._date_filename_dict[date] = filename - self._render_blank_layer(filename) + if not os.path.exists(filename): + shutil.copyfile(base_file, filename) + self._render_blank_layer(filename) else: # Create image file filename = os.path.join(self._tmpdir.name, f"{layer}.png") + shutil.copyfile(base_file, filename) self._date_filename_dict[date] = filename # Render image img = GrassRenderer(filename=filename, use_region=True, env=self._env) - # Fill image background - img.d_erase(bgcolor=self._bgcolor) - for grass_module, kwargs in self._baselayers.calls: - img.run(grass_module, **kwargs) if self._element_type == "strds": img.d_rast(map=layer) elif self._element_type == "stvds": img.d_vect(map=layer) for grass_module, kwargs in self._overlays.calls: img.run(grass_module, **kwargs) - # Add legend if called + # Add legend if needed if self._legend: self._render_legend(img) self._layers_rendered = True From b1f26d91f0937b831ddfe589854378e9ed8fc3a4 Mon Sep 17 00:00:00 2001 From: chaedri Date: Sun, 27 Mar 2022 15:54:03 -0400 Subject: [PATCH 38/45] Update tests, minor improvements --- python/grass/jupyter/display.py | 16 ++--- python/grass/jupyter/tests/timeseries_test.py | 21 +++---- python/grass/jupyter/timeseries.py | 62 +++++++++++++------ 3 files changed, 58 insertions(+), 41 deletions(-) diff --git a/python/grass/jupyter/display.py b/python/grass/jupyter/display.py index a71e0892ff4..49c39ded17c 100644 --- a/python/grass/jupyter/display.py +++ b/python/grass/jupyter/display.py @@ -56,7 +56,7 @@ def __init__( renderer="cairo", use_region=False, saved_region=None, - overwrite=False, + read_file=False, ): """Creates an instance of the GrassRenderer class. @@ -72,11 +72,12 @@ def __init__( :param int text_size: default text size, overwritten by most display modules :param renderer: GRASS renderer driver (options: cairo, png, ps, html) :param use_region: if True, use either current or provided saved region, - else derive region from rendered layers + else derive region from rendered layers :param saved_region: if name of saved_region is provided, - this region is then used for rendering - :param bool overwrite: if true, clear contents of filename with d.erase - before rendering + this region is then used for rendering + :param bool read_file: if False(default), erase filename before re-writing to + clear contents. If True, read file without clearing contents + first. """ # Copy Environment @@ -110,14 +111,13 @@ def cleanup(tmpdir): if filename: self._filename = filename + if not read_file and os.path.exists(self._filename): + os.remove(self._filename) else: self._filename = os.path.join(self._tmpdir.name, "map.png") # Set environment var for file self._env["GRASS_RENDER_FILE"] = self._filename - if filename and overwrite: - gs.run_command("d.erase", env=self._env) - # Create Temporary Legend File self._legend_file = os.path.join(self._tmpdir.name, "legend.txt") self._env["GRASS_LEGEND_FILE"] = str(self._legend_file) diff --git a/python/grass/jupyter/tests/timeseries_test.py b/python/grass/jupyter/tests/timeseries_test.py index 7a80d09acab..8af3e79d156 100644 --- a/python/grass/jupyter/tests/timeseries_test.py +++ b/python/grass/jupyter/tests/timeseries_test.py @@ -29,6 +29,9 @@ def test_collect_layers(space_time_raster_dataset): names, dates = gj.collect_layers( space_time_raster_dataset.name, fill_gaps=False, element_type="strds" ) + # Test fill_gaps=False at empty time step + assert names[1] == "None" + assert dates[1] == '2001-02-01 00:00:00' # Remove the empty time step - see space_time_raster_dataset creation names.pop(1) dates.pop(1) @@ -59,19 +62,15 @@ def test_render_layers(space_time_raster_dataset, fill_gaps): img = gj.TimeSeries(space_time_raster_dataset.name, fill_gaps=fill_gaps) # test baselayer, overlay and d_legend here too for efficiency (rendering is # time-intensive) - # Add first layer in space-time dataset as test baselayer img.baselayer.d_rast(map=space_time_raster_dataset.raster_names[0]) - # test overlay with d_barscale img.overlay.d_barscale() - # test d_legend img.d_legend() # Render layers img.render() - # check files exist: - for ( - _date, - filename, - ) in img._date_filename_dict.items(): # pylint: disable=protected-access + # check files exist + # We need to check values which are only in protected attributes + # pylint: disable=protected-access + for (_date, filename) in img._date_filename_dict.items(): assert Path(filename).is_file() @@ -80,8 +79,4 @@ def test_render_layers(space_time_raster_dataset, fill_gaps): def test_animate_time_slider(space_time_raster_dataset): """Test returns from animate and time_slider are correct object types""" img = gj.TimeSeries(space_time_raster_dataset.name) - assert isinstance(img.animate(), IPython.core.display.Image) - # This doesn't work - # assert isinstance(img.time_slider(), - # (IPython.core.display.Image, - # ipywidgets.widgets.interaction.interactive)) + assert isinstance(img.animate(), IPython.display.Image) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 5cf0bbeeaa0..b07a782fcbe 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -161,7 +161,11 @@ def __init__( :param str element_type: element type, strds (space-time raster dataset) or stvds (space-time vector dataset) :param bool fill_gaps: fill empty time steps with data from previous step - :param str basemap: name of raster to use as basemap/background for visuals + :param str env: environment + :param use_region: if True, use either current or provided saved region, + else derive region from rendered layers + :param saved_region: if name of saved_region is provided, + this region is then used for rendering """ # Copy Environment @@ -233,14 +237,15 @@ def baselayer(self): def set_background_color(self, color): """Set background color of images. - Passed to d.rast and d.erase. Either a standard color name or R:G:B triplet. - Default is White.""" + Passed to d.rast and d.erase. Either a standard color name, R:G:B triplet, or + Hex. Default is White. (add example with hex)""" self._bgcolor = color self._layers_rendered = False def d_legend(self, **kwargs): - """Wrapper for d.legend. Passes keyword arguments to d.legend in render_layers - method. + """Display legend. + + Wraps d.legend and uses same keyword arguments. """ self._legend = kwargs # If d_legend has been called, we need to re-render layers @@ -260,8 +265,13 @@ def _render_legend(self, img): ) def _render_blank_layer(self, filename): - """Write blank image for gaps in time series""" - img = GrassRenderer(filename=filename, use_region=True, env=self._env) + """Write blank image for gaps in time series. + + Adds overlays and legend to base map. + """ + img = GrassRenderer( + filename=filename, use_region=True, env=self._env, read_file=True + ) for grass_module, kwargs in self._overlays.calls: img.run(grass_module, **kwargs) # Add legend if needed @@ -269,38 +279,47 @@ def _render_blank_layer(self, filename): self._render_legend(img) def render(self): - """Renders map for each time-step in space-time dataset and save to PNG - image in temporary directory. - - Must be run before creating a visualization (i.e. time_slider or animate). + """Renders image for each time-step in space-time dataset. - Can be time-consuming to run with large space-time datasets. + Save PNGs to temporary directory. Must be run before creating a visualization + (i.e. time_slider or animate). Can be time-consuming to run with large + space-time datasets. """ # Make base image (background and baselayers) - base_file = os.path.join(self._tmpdir.name, "base.png") - img = GrassRenderer(filename=base_file, use_region=True, env=self._env) + random_name_base = gs.append_random("base", 8) + ".png" + base_file = os.path.join(self._tmpdir.name, random_name_base) + img = GrassRenderer( + filename=base_file, use_region=True, env=self._env, read_file=True + ) # Fill image background img.d_erase(bgcolor=self._bgcolor) # Add baselayers for grass_module, kwargs in self._baselayers.calls: img.run(grass_module, **kwargs) + # Create name for empty layers + random_name_none = gs.append_random("none", 8) + ".png" + # Render each layer for date, layer in self._date_layer_dict.items(): if layer == "None": - filename = os.path.join(self._tmpdir.name, "None.png") + # Create file + filename = os.path.join(self._tmpdir.name, random_name_none) self._date_filename_dict[date] = filename + # Render blank layer if it hasn't been done already if not os.path.exists(filename): shutil.copyfile(base_file, filename) self._render_blank_layer(filename) else: - # Create image file + # Create file filename = os.path.join(self._tmpdir.name, f"{layer}.png") shutil.copyfile(base_file, filename) self._date_filename_dict[date] = filename # Render image - img = GrassRenderer(filename=filename, use_region=True, env=self._env) + img = GrassRenderer( + filename=filename, use_region=True, env=self._env, read_file=True + ) if self._element_type == "strds": img.d_rast(map=layer) elif self._element_type == "stvds": @@ -312,9 +331,8 @@ def render(self): self._render_legend(img) self._layers_rendered = True - def time_slider(self, slider_width="60%"): - """ - Create interactive timeline slider. + def time_slider(self, slider_width=None): + """Create interactive timeline slider. param str slider_width: width of datetime selection slider as a percentage (%) or pixels (px) @@ -327,6 +345,10 @@ def time_slider(self, slider_width="60%"): if not self._layers_rendered: self.render() + # Set default slider width + if not slider_width: + slider_width = "60%" + # Datetime selection slider slider = widgets.SelectionSlider( options=self._dates, From e80d68fead45a5e5fc1da036a77afdab775ccdaf Mon Sep 17 00:00:00 2001 From: chaedri Date: Sun, 27 Mar 2022 15:56:48 -0400 Subject: [PATCH 39/45] black --- python/grass/jupyter/tests/timeseries_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/grass/jupyter/tests/timeseries_test.py b/python/grass/jupyter/tests/timeseries_test.py index 8af3e79d156..06327087b28 100644 --- a/python/grass/jupyter/tests/timeseries_test.py +++ b/python/grass/jupyter/tests/timeseries_test.py @@ -31,7 +31,7 @@ def test_collect_layers(space_time_raster_dataset): ) # Test fill_gaps=False at empty time step assert names[1] == "None" - assert dates[1] == '2001-02-01 00:00:00' + assert dates[1] == "2001-02-01 00:00:00" # Remove the empty time step - see space_time_raster_dataset creation names.pop(1) dates.pop(1) From 12d3901c587b8a95a411c5ffc48bd0cc3a30feb0 Mon Sep 17 00:00:00 2001 From: chaedri Date: Sun, 27 Mar 2022 16:44:42 -0400 Subject: [PATCH 40/45] Update temporal examples --- doc/notebooks/temporal.ipynb | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/doc/notebooks/temporal.ipynb b/doc/notebooks/temporal.ipynb index e65ae9441bb..81dc1378a76 100644 --- a/doc/notebooks/temporal.ipynb +++ b/doc/notebooks/temporal.ipynb @@ -217,9 +217,11 @@ "metadata": {}, "outputs": [], "source": [ - "img = gj.TimeSeries(\"precip_sum_2010\")\n", - "img.d_legend(color=\"gray\", at=(10, 0, 30, 0)) # Add legend\n", - "img.time_slider() # Create TimeSlider" + "img = gj.TimeSeries(\"precip_sum_2010\", fill_gaps=False, use_region=True)\n", + "img.d_legend(color=\"black\", at=(10,40,2,6)) #Add legend\n", + "img.overlay.d_vect(map=\"boundary_county\", fill_color=\"none\")\n", + "img.overlay.d_barscale()\n", + "img.time_slider()" ] }, { @@ -272,6 +274,24 @@ "img2.d_legend(color=\"gray\", at=(10, 0, 30, 0)) # Add legend\n", "img2.time_slider() # Create TimeSlider" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, `fill_gaps=False`, so there is are blank images where we removed rasters. By setting `fill_gaps=True`, we will see the gap filled by the previous time step." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "img3 = gj.TimeSeries(\"precip_sum_2010\", fill_gaps=True)\n", + "img3.d_legend(color=\"gray\", at=(10, 0, 30, 0)) # Add legend\n", + "img3.time_slider() # Create TimeSlider" + ] } ], "metadata": { From ef393812786e0c1f2fa193e73078ed04dab400a5 Mon Sep 17 00:00:00 2001 From: chaedri Date: Mon, 11 Apr 2022 11:48:21 -0400 Subject: [PATCH 41/45] Minor Edits from PR --- python/grass/jupyter/display.py | 5 +- python/grass/jupyter/tests/timeseries_test.py | 4 +- python/grass/jupyter/timeseries.py | 51 ++++++++++++------- 3 files changed, 39 insertions(+), 21 deletions(-) diff --git a/python/grass/jupyter/display.py b/python/grass/jupyter/display.py index 49c39ded17c..efdb4b993de 100644 --- a/python/grass/jupyter/display.py +++ b/python/grass/jupyter/display.py @@ -30,6 +30,7 @@ class GrassRenderer: Elements are added to the display by calling GRASS display modules. Basic usage:: + >>> m = GrassRenderer() >>> m.run("d.rast", map="elevation") >>> m.run("d.legend", raster="elevation") @@ -39,10 +40,12 @@ class GrassRenderer: as a class method and replacing "." with "_" in the name. Shortcut usage:: + >>> m = GrassRenderer() >>> m.d_rast(map="elevation") >>> m.d_legend(raster="elevation") >>> m.show() + """ def __init__( @@ -75,7 +78,7 @@ def __init__( else derive region from rendered layers :param saved_region: if name of saved_region is provided, this region is then used for rendering - :param bool read_file: if False(default), erase filename before re-writing to + :param bool read_file: if False (default), erase filename before re-writing to clear contents. If True, read file without clearing contents first. """ diff --git a/python/grass/jupyter/tests/timeseries_test.py b/python/grass/jupyter/tests/timeseries_test.py index 06327087b28..a34edd53918 100644 --- a/python/grass/jupyter/tests/timeseries_test.py +++ b/python/grass/jupyter/tests/timeseries_test.py @@ -55,7 +55,7 @@ def test_default_init(space_time_raster_dataset): assert img.timeseries == space_time_raster_dataset.name -@pytest.mark.parametrize("fill_gaps", ["False", "True"]) +@pytest.mark.parametrize("fill_gaps", [False, True]) def test_render_layers(space_time_raster_dataset, fill_gaps): """Check that layers are rendered""" # create instance of TimeSeries @@ -70,7 +70,7 @@ def test_render_layers(space_time_raster_dataset, fill_gaps): # check files exist # We need to check values which are only in protected attributes # pylint: disable=protected-access - for (_date, filename) in img._date_filename_dict.items(): + for unused_date, filename in img._date_filename_dict.items(): assert Path(filename).is_file() diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index b07a782fcbe..26cba69cdda 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -44,7 +44,7 @@ def collect_layers(timeseries, element_type, fill_gaps): :param str element_type: element type, "stvds" or "strds" :param bool fill_gaps: fill empty time steps with data from previous step """ - # NEW WAY: Comment in after PR 2258 is merged + # NEW WAY: Comment in after json output for t.rast.list and t.vect.list is merged # import json # if element_type == "strds": # result = json.loads( @@ -134,9 +134,10 @@ class TimeSeries: Notebooks. Basic usage:: + >>> img = TimeSeries("series_name") - >>> img.d_legend() #Add legend - >>> img.time_slider() #Create TimeSlider + >>> img.d_legend() # Add legend + >>> img.time_slider() # Create TimeSlider >>> img.animate() This class of grass.jupyter is experimental and under development. The API can @@ -238,7 +239,13 @@ def set_background_color(self, color): """Set background color of images. Passed to d.rast and d.erase. Either a standard color name, R:G:B triplet, or - Hex. Default is White. (add example with hex)""" + Hex. Default is white. + + >>> img = TimeSeries("series_name") + >>> img.set_background_color("#088B36") # GRASS GIS green + >>> img.animate() + + """ self._bgcolor = color self._layers_rendered = False @@ -278,6 +285,20 @@ def _render_blank_layer(self, filename): if self._legend: self._render_legend(img) + def _render_layer(self, layer, filename): + img = GrassRenderer( + filename=filename, use_region=True, env=self._env, read_file=True + ) + if self._element_type == "strds": + img.d_rast(map=layer) + elif self._element_type == "stvds": + img.d_vect(map=layer) + for grass_module, kwargs in self._overlays.calls: + img.run(grass_module, **kwargs) + # Add legend if needed + if self._legend: + self._render_legend(img) + def render(self): """Renders image for each time-step in space-time dataset. @@ -287,6 +308,7 @@ def render(self): """ # Make base image (background and baselayers) + # Random name needed to avoid potential conflict with layer names random_name_base = gs.append_random("base", 8) + ".png" base_file = os.path.join(self._tmpdir.name, random_name_base) img = GrassRenderer( @@ -299,6 +321,7 @@ def render(self): img.run(grass_module, **kwargs) # Create name for empty layers + # Random name needed to avoid potential conflict with layer names random_name_none = gs.append_random("none", 8) + ".png" # Render each layer @@ -317,25 +340,17 @@ def render(self): shutil.copyfile(base_file, filename) self._date_filename_dict[date] = filename # Render image - img = GrassRenderer( - filename=filename, use_region=True, env=self._env, read_file=True - ) - if self._element_type == "strds": - img.d_rast(map=layer) - elif self._element_type == "stvds": - img.d_vect(map=layer) - for grass_module, kwargs in self._overlays.calls: - img.run(grass_module, **kwargs) - # Add legend if needed - if self._legend: - self._render_legend(img) + self._render_layer(layer, filename) self._layers_rendered = True def time_slider(self, slider_width=None): """Create interactive timeline slider. - param str slider_width: width of datetime selection slider as a - percentage (%) or pixels (px) + param str slider_width: width of datetime selection slider + + The slider_width parameter sets the width of the slider in the output cell. + It should be formantted as a percentage (%) of the cell width or in pixels (px). + slider_width is passed to ipywidgets in ipywidgets.Layout(width=slider_width). """ # Lazy Imports import ipywidgets as widgets # pylint: disable=import-outside-toplevel From 31233649d6980ef4aa2fc8cc7434e7036d570758 Mon Sep 17 00:00:00 2001 From: chaedri Date: Tue, 12 Apr 2022 21:32:28 -0400 Subject: [PATCH 42/45] Minor changes discussed in grass.jupyter meeting --- python/grass/jupyter/timeseries.py | 29 ++++++++++++++++++++++------- 1 file changed, 22 insertions(+), 7 deletions(-) diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 26cba69cdda..67937f09eae 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -258,6 +258,11 @@ def d_legend(self, **kwargs): # If d_legend has been called, we need to re-render layers self._layers_rendered = False + def _render_baselayers(self, img): + """Add collected baselayers to GrassRenderer instance""" + for grass_module, kwargs in self._baselayers.calls: + img.run(grass_module, **kwargs) + def _render_legend(self, img): """Add legend to GrassRenderer instance""" info = gs.parse_command( @@ -271,6 +276,11 @@ def _render_legend(self, img): **self._legend, ) + def _render_overlays(self, img): + """Add collected overlays to GrassRenderer instance""" + for grass_module, kwargs in self._overlays.calls: + img.run(grass_module, **kwargs) + def _render_blank_layer(self, filename): """Write blank image for gaps in time series. @@ -279,13 +289,14 @@ def _render_blank_layer(self, filename): img = GrassRenderer( filename=filename, use_region=True, env=self._env, read_file=True ) - for grass_module, kwargs in self._overlays.calls: - img.run(grass_module, **kwargs) + # Add overlays + self._render_overlays(img) # Add legend if needed if self._legend: self._render_legend(img) def _render_layer(self, layer, filename): + """Render layer to file with overlays and legend""" img = GrassRenderer( filename=filename, use_region=True, env=self._env, read_file=True ) @@ -293,8 +304,8 @@ def _render_layer(self, layer, filename): img.d_rast(map=layer) elif self._element_type == "stvds": img.d_vect(map=layer) - for grass_module, kwargs in self._overlays.calls: - img.run(grass_module, **kwargs) + # Add overlays + self._render_overlays(img) # Add legend if needed if self._legend: self._render_legend(img) @@ -317,11 +328,12 @@ def render(self): # Fill image background img.d_erase(bgcolor=self._bgcolor) # Add baselayers - for grass_module, kwargs in self._baselayers.calls: - img.run(grass_module, **kwargs) + self._render_baselayers(img) # Create name for empty layers # Random name needed to avoid potential conflict with layer names + # A new random_name_none is created each time the render function is run, + # and any existing random_name_none file will be ignored random_name_none = gs.append_random("none", 8) + ".png" # Render each layer @@ -337,6 +349,7 @@ def render(self): else: # Create file filename = os.path.join(self._tmpdir.name, f"{layer}.png") + # Copying the base_file ensures that previous results are overwritten shutil.copyfile(base_file, filename) self._date_filename_dict[date] = filename # Render image @@ -349,7 +362,9 @@ def time_slider(self, slider_width=None): param str slider_width: width of datetime selection slider The slider_width parameter sets the width of the slider in the output cell. - It should be formantted as a percentage (%) of the cell width or in pixels (px). + It should be formatted as a percentage (%) between 0 and 100 of the cell width + or in pixels (px). Values should be formatted as strings and include the "%"% + or "px" suffix. For example, slider_width="80%" or slider_width="500px") slider_width is passed to ipywidgets in ipywidgets.Layout(width=slider_width). """ # Lazy Imports From c3b493e120d24271b0daf5eff39e2121819a4709 Mon Sep 17 00:00:00 2001 From: Vaclav Petras Date: Tue, 12 Apr 2022 22:47:31 -0400 Subject: [PATCH 43/45] Fix syntax broken during merge and typos --- python/grass/jupyter/tests/conftest.py | 2 +- python/grass/jupyter/timeseries.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/python/grass/jupyter/tests/conftest.py b/python/grass/jupyter/tests/conftest.py index e7e86ed908d..42bd1bd2235 100644 --- a/python/grass/jupyter/tests/conftest.py +++ b/python/grass/jupyter/tests/conftest.py @@ -65,7 +65,7 @@ def space_time_raster_dataset(tmp_path_factory): raster_names=names, full_raster_names=full_names, start_times=times, - + ) @pytest.fixture(scope="module") def simple_dataset(tmp_path_factory): diff --git a/python/grass/jupyter/timeseries.py b/python/grass/jupyter/timeseries.py index 67937f09eae..6befe01b11a 100644 --- a/python/grass/jupyter/timeseries.py +++ b/python/grass/jupyter/timeseries.py @@ -363,8 +363,8 @@ def time_slider(self, slider_width=None): The slider_width parameter sets the width of the slider in the output cell. It should be formatted as a percentage (%) between 0 and 100 of the cell width - or in pixels (px). Values should be formatted as strings and include the "%"% - or "px" suffix. For example, slider_width="80%" or slider_width="500px") + or in pixels (px). Values should be formatted as strings and include the "%" + or "px" suffix. For example, slider_width="80%" or slider_width="500px". slider_width is passed to ipywidgets in ipywidgets.Layout(width=slider_width). """ # Lazy Imports From 02921f15ea75d80adf10ff3cf7bd29d677103b10 Mon Sep 17 00:00:00 2001 From: Vaclav Petras Date: Tue, 12 Apr 2022 22:50:24 -0400 Subject: [PATCH 44/45] Missing empty from "suggestion" fix --- python/grass/jupyter/tests/conftest.py | 1 + 1 file changed, 1 insertion(+) diff --git a/python/grass/jupyter/tests/conftest.py b/python/grass/jupyter/tests/conftest.py index 42bd1bd2235..fb3e9bdc403 100644 --- a/python/grass/jupyter/tests/conftest.py +++ b/python/grass/jupyter/tests/conftest.py @@ -67,6 +67,7 @@ def space_time_raster_dataset(tmp_path_factory): start_times=times, ) + @pytest.fixture(scope="module") def simple_dataset(tmp_path_factory): """Start a session and create a raster time series From d79e9e4b021ed502605d52913866ccee0e888409 Mon Sep 17 00:00:00 2001 From: Vaclav Petras Date: Tue, 12 Apr 2022 22:51:44 -0400 Subject: [PATCH 45/45] Improve indent after merge --- python/grass/jupyter/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/grass/jupyter/Makefile b/python/grass/jupyter/Makefile index 3f25c4e544e..cdf0cb392e7 100644 --- a/python/grass/jupyter/Makefile +++ b/python/grass/jupyter/Makefile @@ -11,7 +11,7 @@ MODULES = \ interact_display \ region \ render3d \ - reprojection_renderer \ + reprojection_renderer \ utils \ timeseries \ utils