colab_notebook.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "V5FdN92AUR_q"
   },
   "source": [
    "# Prepare the Environment\n",
    "\n",
    " This installs GRASS GIS, gets the workshop materials, and downloads the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tW-I7tg_85X6"
   },
   "outputs": [],
   "source": [
    "%%bash\n",
    "DEBIAN_FRONTEND=noninteractive sudo add-apt-repository ppa:ubuntugis/ubuntugis-unstable && apt update && apt install grass xvfb\n",
    "pip install PyVirtualDisplay\n",
    "git clone https://github.com/ncsu-geoforall-lab/introduction-to-grass-processing-bu-2025\n",
    "cd introduction-to-grass-processing-bu-2025\n",
    "sh download_data.sh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "UCdzD3IbTbFb"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "os.chdir(\"introduction-to-grass-processing-bu-2025\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 1: GRASS GIS intro\n",
    "\n",
    "## Author and Acknowledgement\n",
    "\n",
    "<img src=\"img/ncsu_cga.png\" title=\"Center for Geospatial Analytics at NC State\" width=400>\n",
    "\n",
    "Vaclav (Vashek) Petras, NC State University, Center for Geospatial Analytics\n",
    "\n",
    "Supported by the U.S. National Science Foundation, award [2303651](https://www.nsf.gov/awardsearch/showAward?AWD_ID=2303651).\n",
    "\n",
    "\n",
    "<img src=\"img/vaclav_petras.jpg\" title=\"Vaclav Petras\" width=150>\n",
    "\n",
    "<img src=\"img/NSF_logo.png\" title=\"NSF\" width=150>\n",
    "\n",
    "In this first part, we will demonstrate starting GRASS GIS, creating new project and basic data visualization."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook environment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default all cells in a notebook are running Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "\n",
    "v = sys.version_info\n",
    "print(f\"We are using Python {v.major}.{v.minor}.{v.micro}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cells can also run Bash using IPython magic. Later, we will use this to show how GRASS can be used from command line (this assumes that the machine has Bash)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "grass --version"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use ! to run individual lines in command line (we won't use it in this notebook, but this works on all machines even if they don't have Bash, although the available commands will be different)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Start GRASS GIS"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load Python libraries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Python standard library and IPython packages we need.\n",
    "import subprocess\n",
    "import sys\n",
    "\n",
    "# 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 the GRASS packages we need.\n",
    "import grass.script as gs\n",
    "import grass.jupyter as gj"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we create new empty project (previously known as location) called *dix_park* that uses projection [UTM zone 17 N](https://epsg.io/6346) with EPSG:6346."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new GRASS project\n",
    "gs.create_project(\"dix_park\", epsg=6346)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Start GRASS GIS session in the newly created project:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start GRASS session\n",
    "session = gj.init(\"dix_park\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import data"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\">\n",
    "If you run this workshop in MyBinder or Google Colab, the data is already prepared in the environment at this point. Otherwise, download the data <a href=\"https://zenodo.org/records/6967699/files/FOSS4G_2022_GRASS_GIS_workshop.zip?download=1\">here</a>.\n",
    "</div>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will import pre-downloaded OSM data of roads restricted to our study area. We obtained the roads using Overpass Turbo with this [query](https://overpass-turbo.eu/s/1aGu) and exported to GeoJSON.\n",
    "\n",
    "The data comes in EPSG:4326, so it will be automatically reprojected to UTM during the import."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\"v.import\", input=\"roads.geojson\", output=\"roads\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we will import prepared digital surface model (DSM), bare ground (digital terrain model, DTM) and ortho maps.\n",
    "The data CRS matches the CRS of our *dix_park* project, so we don't need to reproject it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "r.import input=dsm.tif output=dsm resample=bilinear\n",
    "r.import input=ground.tif output=ground\n",
    "r.import input=ortho.tif output=ortho"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's look at the available data in our project:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "g.list type=raster,vector -m -t"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schema of GRASS project dix_park's content:\n",
    "\n",
    "<img src=\"img/data_structure1.png\" alt=\"GRASS project dix_park\" width=\"200\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data visualization\n",
    "\n",
    "We will call _d.rast_ and _d.vect_ modules using the [GRASS Jupyter API](https://grass.osgeo.org/grass-stable/manuals/libpython/grass.jupyter.html). The `Map` class creates and displays GRASS maps as static PNG images.\n",
    "\n",
    "First let's display bare ground elevation with the roads dataset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Map instance\n",
    "elevation_map = gj.Map()\n",
    "# Add a raster and vector to the map\n",
    "elevation_map.d_rast(map=\"ground\")\n",
    "elevation_map.d_vect(map=\"roads\")\n",
    "elevation_map.d_legend(raster=\"ground\")\n",
    "# Display map\n",
    "elevation_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, display road _Umstead Drive_ in yellow on top of ortho. Method `d_vect` can be called with options of [d.vect](https://grass.osgeo.org/grass-stable/manuals/d.vect.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ortho_map = gj.Map()\n",
    "ortho_map.d_rast(map=\"ortho\")\n",
    "ortho_map.d_vect(map=\"roads\", width=\"2\", color=\"yellow\", where=\"name = 'Umstead Drive'\")\n",
    "ortho_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is how we can visualize data interactively with folium:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "roads_map = gj.InteractiveMap()\n",
    "roads_map.add_raster(\"dsm\", opacity=0.5)\n",
    "roads_map.add_vector(\"roads\")\n",
    "roads_map.add_layer_control(position=\"bottomright\")\n",
    "roads_map.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also visualize data in 3D. Here we drape the ortho over the DSM."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map3d = gj.Map3D()\n",
    "map3d.render(\n",
    "    elevation_map=\"dsm\",\n",
    "    color_map=\"ortho\",\n",
    "    position=(0.5, 1),\n",
    "    height=3000,\n",
    "    perspective=12,\n",
    ")\n",
    "map3d.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map3d = gj.Map3D()\n",
    "map3d.render(\n",
    "    elevation_map=\"dsm\",\n",
    "    resolution_fine=1,\n",
    "    color_map=\"ortho\",\n",
    "    light_position=(1, 0, 0.5),\n",
    "    position=(0.75, 0.35),\n",
    "    height=1500,\n",
    "    perspective=10,\n",
    ")\n",
    "map3d.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## GRASS GIS tools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GRASS functionality is available through tools (also called modules). There are over 500 different tools in the core distribution and over 300 addon tools that can be used to prepare and analyze data.\n",
    "\n",
    "Tools respect the following naming conventions:\n",
    "\n",
    "Prefix | Function | Example\n",
    "------ | -------- | -------\n",
    "r.* | raster processing | r.mapcalc: map algebra\n",
    "v.*\t| vector processing\t| v.clean: topological cleaning\n",
    "i.*\t| imagery processing | i.segment: object recognition\n",
    "db.* | database management | db.select: select values from table\n",
    "r3.* | 3D raster processing | r3.stats: 3D raster statistics\n",
    "t.* | temporal data processing | t.rast.aggregate: temporal aggregation\n",
    "g.* | general data management | g.rename: renames map\n",
    "d.* | display | d.rast: display raster map\n",
    "\n",
    "Note also that some tools have multiple dots in their names. For example, tools staring with v.net.* deal with vector network analysis and r.in.* tools import raster data into GRASS GIS spatial database.\n",
    "\n",
    "There is a tool for finding other tools:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "g.search.modules keyword=zonal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is how to get all options and flags of a GRASS tool:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "r.univar --help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will open the tool's manual page in your web browser. It will work only locally. The page is available [online](https://grass.osgeo.org/grass83/manuals/r.univar.html) for each version.\n",
    "\n",
    "```\n",
    "g.manual r.univar\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GRASS modules can be executed either through the GUI, command line or Python interfaces. This is an example how to execute a tool in command line. Specifically, it will extract road _Umstead Drive_ into a new vector `umstead_drive_segments`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "v.extract input=roads where=\"name = 'Umstead Drive'\" output=umstead_drive_segments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now the same in Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\n",
    "    \"v.extract\",\n",
    "    input=\"roads\",\n",
    "    where=\"name = 'Umstead Drive'\",\n",
    "    output=\"umstead_drive_segments\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computational region"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computational region is an important raster concept in GRASS GIS, that allows you to fully control the **extent** and **resolution** of your raster computations.\n",
    "All raster computations will be performed in the specified extent and with the given resolution to ensure consistency.\n",
    "Among other things, computational region allows us to easily subset larger extent data for quicker testing of analysis, or to run an analysis of specific regions given by e.g. administrative units.\n",
    "\n",
    "A few points to keep in mind:\n",
    "\n",
    " * computational region is defined by extent and resolution\n",
    " * applies to all raster operations and vector to raster operations\n",
    " * persists between GRASS sessions, can be different for different mapsets (subprojects)\n",
    " * advantages: keeps your results consistent, avoids clipping, facilitates experimentation (for computationally demanding tasks set region to smaller extent, check that your result is good and then set the computational region to the entire study area and rerun analysis)\n",
    "\n",
    "Run `g.region -p` to see current region settings:\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "g.region -p"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common way to set region is **based on a raster map** - both extent and resolution. Run again g.region (we include -p flag to always see the resulting region):\n",
    "\n",
    "<img src=\"img/region_raster.png\" alt=\"Region set to raster\" width=\"200\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "g.region -p raster=dsm"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computational region can be set also **using a vector map**. In that case, only extent is set (as vector maps do not have any resolution - at least not in the way raster maps do). The resolution needs to be adjusted based on the new extent:\n",
    "\n",
    "<img src=\"img/region_vector.png\" alt=\"Region set to vector\" width=\"200\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "g.region -p vector=roads"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However now the resolution was adjusted based on the extent of the vector map, it is no longer a nice rounded number and it doesn't align with the raster. If that's not desired, we can set set the extent based on a vector map, but **align** the resolution to a raster map:\n",
    "\n",
    "<img src=\"img/region_vector_align.png\" alt=\"Region set to vector and aligned with raster\" width=\"200\"/>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "g.region -p vector=roads align=dsm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can save a specific region for later. This won't actually modify the current region:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "g.region vector=umstead_drive_segments align=dsm save=road_region"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Saved region can be used later on, for example to set the rendering extent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "elevation_map = gj.Map(saved_region=\"road_region\")\n",
    "elevation_map.d_rast(map=\"dsm\")\n",
    "elevation_map.d_vect(map=\"umstead_drive_segments\")\n",
    "elevation_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python API"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two Python APIs for accessing a tool's functionality - [GRASS GIS Python Scripting Library](https://grass.osgeo.org/grass-stable/manuals/libpython/script_intro.html) and [PyGRASS](https://grass.osgeo.org/grass-stable/manuals/libpython/pygrass_index.html).\n",
    "PyGRASS is advantageous for more advanced workflows. Here we will be using Python Scripting Library (`import grass.script as gs`)\n",
    "as it is simple to use and sufficient for our purposes.\n",
    "\n",
    "GRASS GIS Python Scripting Library provides functions to call GRASS modules within scripts as subprocesses. The most often used functions include:\n",
    "\n",
    " * [run_command()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.core.run_command): used with modules which output raster/vector data where text output is not expected\n",
    " * [read_command()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.core.read_command): used when we are interested in text output\n",
    " * [parse_command()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.core.parse_command): used with modules producing text output as key=value pair\n",
    " * [write_command()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.core.write_command): for modules expecting text input from either standard input or file\n",
    "\n",
    "It also provides several wrapper functions for often called modules. The list of convenient wrapper functions with examples includes:\n",
    "\n",
    " * Raster metadata using [raster_info()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.raster.raster_info): `gs.raster_info('dsm')`\n",
    " * Vector metadata using [vector_info()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.vector.vector_info): `gs.vector_info('roads')`\n",
    " * List raster data in current project using [list_grouped()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.core.list_grouped): `gs.list_grouped(type=['raster'])`\n",
    " * Get current computational region using [region()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.core.region): `gs.region()`\n",
    " * Run raster algebra using [mapcalc()](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.raster.mapcalc): `gs.mapcalc()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's practice!\n",
    "Compute viewshed in Python.\n",
    "1. Set computational region to match raster `dsm`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Compute binary viewshed (visible - 1, not visible - 0) using [r.viewshed](https://grass.osgeo.org/grass-stable/manuals/r.viewshed.html) using `dsm` raster from X=711260 and Y=3960860:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Display the viewshed overlaid over the orthophoto `ortho`. Use [d.rast](https://grass.osgeo.org/grass-stable/manuals/d.rast.html)'s `values` to display only visible cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Compute size of the visible area, using [r.univar](https://grass.osgeo.org/grass-stable/manuals/r.univar.html) computing univariate statistics. Use `gs.parse_command()` together with r.univar's `-g` flag to get a number of visible cells. Use `gs.region()` to get the cell size. Compute area in hectares (ha, 1 ha is 10,000 square meters). Compute also percentage of area that is visible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Find answers by you editing this cell (double click to see the answers).\n",
    "<!--\n",
    "# 1. set computational region based on DSM\n",
    "gs.run_command(\"g.region\", raster=\"dsm\")\n",
    "\n",
    "# 2. Compute viewshed, flag 'b' is for binary (0 and 1) output \n",
    "gs.run_command(\"r.viewshed\", input=\"dsm\", output=\"viewshed\", flags=\"b\", coordinates=(711260, 3960860))\n",
    "\n",
    "# 3. Display the viewshed\n",
    "viewshed_map = gj.Map()\n",
    "viewshed_map.d_rast(map=\"ortho\")\n",
    "# select only cells with value 1 to visualize\n",
    "viewshed_map.d_rast(map=\"viewshed\", values=1)\n",
    "viewshed_map.show()\n",
    "\n",
    "# 3. Compute viewshed size\n",
    "\n",
    "# Compute basic univariate statistics, flag 'g' is for parsable output\n",
    "univar = gs.parse_command(\"r.univar\", map=\"viewshed\", flags='g')\n",
    "# Get current region settings to get cell size\n",
    "region = gs.region()\n",
    "cell_size = region[\"nsres\"] * region[\"ewres\"]\n",
    "# Compute the percentage and size\n",
    "percentage = 100 * float(univar['sum']) / float(univar['n'])\n",
    "area = cell_size * float(univar['sum'])\n",
    "print(f\"Percentage of visible area is {percentage:.2f}%, which is {area / 10000:.2f} ha\")\n",
    "\n",
    "-->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 2: Viewshed case study\n",
    "\n",
    "In the second part, we will demonstrate the use of GRASS for a small viewshed case study.\n",
    "The goal is to **compute and analyze the area a driver would see from a road**.\n",
    "This notebook can be run only after notebook Part 1 was executed.\n",
    "\n",
    "Topics covered:\n",
    " * Python scripting\n",
    " * manipulating vector data ([v.build.polylines](https://grass.osgeo.org/grass-stable/manuals/v.build.polylines.html), [v.to.points](https://grass.osgeo.org/grass-stable/manuals/v.to.points.html))\n",
    " * vector attributes ([v.db.select](https://grass.osgeo.org/grass-stable/manuals/v.db.select.html))\n",
    " * viewshed computation ([r.viewshed](https://grass.osgeo.org/grass-stable/manuals/r.viewshed.html))\n",
    " * region handling ([grass.script.region_env](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#script.core.region_env))\n",
    " * raster algebra ([r.mapcalc](https://grass.osgeo.org/grass-stable/manuals/r.mapcalc.html))\n",
    " * temporal data handling ([temporal tools](https://grass.osgeo.org/grass-stable/manuals/temporalintro.html))\n",
    " * raster mask ([r.mask](https://grass.osgeo.org/grass-stable/manuals/r.mask.html))\n",
    " * raster as numpy array ([grass.script.array](https://grass.osgeo.org/grass-stable/manuals/libpython/script.html#module-script.array))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load Python libraries. (This may be be skipped in the Google Colab notebook where we already did this  at the beginning of the single, long notebook.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import Python standard library and IPython packages we need.\n",
    "import subprocess\n",
    "import sys\n",
    "\n",
    "# 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 the GRASS GIS packages we need.\n",
    "import grass.script as gs\n",
    "import grass.jupyter as gj"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous notebook (Part 1) we created new project *dix_park*. This automatically created new default mapset (subproject) _PERMANENT_ where we then imported our base data. Now it's time to create a new mapset for our viewshed analysis, we will name it _viewsheds_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from grass.experimental import require_create_ensure_mapset\n",
    "\n",
    "# Create mapset if it does not exist and continue if it already exists.\n",
    "require_create_ensure_mapset(\"dix_park/viewsheds\", ensure=True)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schema of GRASS project _dix_park_'s content:\n",
    "\n",
    "<img src=\"img/data_structure2.png\" alt=\"GRASS project dix_park\" width=\"400\"/>"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Start a new session in the mapset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Start GRASS session\n",
    "session = gj.init(\"dix_park/viewsheds\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data preparation\n",
    "We will first derive viewpoints along the road *Umstead Drive* (vector `umstead_drive_segments`) that we extracted in the first part of the workshop.\n",
    "\n",
    "Because the road consists of several segments, we will first merge them into one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\n",
    "    \"v.build.polylines\",\n",
    "    input=\"umstead_drive_segments\",\n",
    "    output=\"umstead_drive\",\n",
    "    cats=\"first\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then create new vector of points along the line with distance 50 m:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\n",
    "    \"v.to.points\", input=\"umstead_drive\", type=\"line\", output=\"viewpoints\", dmax=50\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize the points with InteractiveMap with OSM tiles (see [other tile options](https://grass.osgeo.org/grass-stable/manuals/libpython/grass.jupyter.html#module-grass.jupyter.interactivemap)):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "road_map = gj.InteractiveMap(tiles=\"OpenStreetMap\")\n",
    "road_map.add_vector(\"umstead_drive\")\n",
    "road_map.add_vector(\"viewpoints\")\n",
    "road_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next part of analysis is raster-based, so we need to make sure we set computational region as we need. Specifically, we set it to match the DSM:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\"g.region\", raster=\"dsm\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we want to compute the visibility using DSM, however some points may fall on top of a tree, so we need to filter those out.\n",
    "\n",
    "First compute height above ground (DSM - DTM) using raster algebra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.mapcalc(\"diff = dsm - ground\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set the color ramp of the raster to \"differences\", which will highlight in red areas with vegetation and buildings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\"r.colors\", map=\"diff\", color=\"differences\")\n",
    "\n",
    "diff_map = gj.Map()\n",
    "diff_map.d_rast(map=\"diff\")\n",
    "diff_map.d_vect(map=\"umstead_drive\")\n",
    "diff_map.d_legend(raster=\"diff\")\n",
    "diff_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extract height above ground for the viewpoint locations to identify points that fall on top of a tree growing next to the road:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\"v.what.rast\", map=\"viewpoints\", layer=2, raster=\"diff\", column=\"height\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the newly computed attribute data. This example shows how the attribute data can be loaded into pandas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pandas as pd\n",
    "\n",
    "pd.DataFrame(\n",
    "    json.loads(\n",
    "        gs.read_command(\n",
    "            \"v.db.select\",\n",
    "            map=\"viewpoints\",\n",
    "            columns=\"cat,height\",\n",
    "            layer=2,\n",
    "            format=\"json\",\n",
    "        )\n",
    "    )[\"records\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize the viewpoints with the height-above-ground raster. You can filter the points based on the height above ground, we won't display points with height > 2.\n",
    "Additionally, we will render the result larger (`width=1000`) and we will render the map zoomed in to the area with the points\n",
    "by saving a region and using it in Map (`saved_region=\"umstead_drive_region\"`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\n",
    "    \"g.region\",\n",
    "    vector=\"umstead_drive\",\n",
    "    align=\"dsm\",\n",
    "    grow=200,\n",
    "    save=\"umstead_drive_region\",\n",
    ")\n",
    "\n",
    "img = gj.Map(width=1000, saved_region=\"umstead_drive_region\")\n",
    "img.d_rast(map=\"diff\")\n",
    "img.d_vect(map=\"umstead_drive\")\n",
    "img.d_vect(\n",
    "    map=\"viewpoints\",\n",
    "    layer=2,\n",
    "    where=\"height >= 2\",\n",
    "    size=15,\n",
    "    icon=\"basic/pin\",\n",
    "    fill_color=\"red\",\n",
    ")\n",
    "img.d_vect(map=\"viewpoints\", layer=2, where=\"height < 2\", size=15, icon=\"basic/pin\")\n",
    "img.d_legend(raster=\"diff\")\n",
    "img.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Viewshed computation\n",
    "We will compute viewsheds from all the viewpoints we generated earlier and from those we compute a cumulative viewshed.\n",
    "First, we get the list coordinates of the viewpoints that are likely lying on the ground:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import io\n",
    "\n",
    "viewpoints = gs.read_command(\n",
    "    \"v.out.ascii\", input=\"viewpoints\", separator=\"comma\", layer=2, where=\"height < 2\"\n",
    ")\n",
    "reader = csv.reader(io.StringIO(viewpoints))\n",
    "viewpoints = list(reader)\n",
    "viewpoints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will now compute the viewshed from each viewpoint in a loop. We set max distance of 300 m. Each viewshed will be named `viewshed_{cat}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "maps = []\n",
    "for x, y, cat in tqdm(viewpoints):\n",
    "    name = f\"viewshed_{cat}\"\n",
    "    gs.run_command(\n",
    "        \"r.viewshed\",\n",
    "        input=\"dsm\",\n",
    "        output=name,\n",
    "        coordinates=(x, y),\n",
    "        max_distance=300,\n",
    "        flags=\"b\",\n",
    "    )\n",
    "    maps.append(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = gj.Map(width=1000, saved_region=\"umstead_drive_region\")\n",
    "img.d_rast(map=\"diff\")\n",
    "for name in tqdm(maps):\n",
    "    img.d_rast(map=name, values=1)\n",
    "img.d_vect(map=\"umstead_drive\")\n",
    "img.d_vect(\n",
    "    map=\"viewpoints\",\n",
    "    layer=2,\n",
    "    where=\"height >= 2\",\n",
    "    size=15,\n",
    "    icon=\"basic/pin\",\n",
    "    fill_color=\"red\",\n",
    ")\n",
    "img.d_vect(map=\"viewpoints\", layer=2, where=\"height < 2\", size=15, icon=\"basic/pin\")\n",
    "img.d_legend(raster=\"diff\")\n",
    "img.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Temporal dataset of viewsheds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this part we will create, analyze and visualize a temporal dataset of viewsheds using [temporal tools](https://grass.osgeo.org/grass-stable/manuals/temporal.html). \n",
    "\n",
    "First, let's check we have the viewshed rasters ready:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.list_strings(type=\"raster\", pattern=\"viewshed_*\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will create an empty space-time raster dataset called _viewsheds_ with relative temporal type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\n",
    "    \"t.create\",\n",
    "    output=\"viewsheds\",\n",
    "    type=\"strds\",\n",
    "    temporaltype=\"relative\",\n",
    "    title=\"Viewshed series\",\n",
    "    description=\"Series of viewsheds along a road\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we register the viewshed rasters with start time 1 and 1-minute increment to simulate a change of view of a car driving slowly along the road:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\n",
    "    \"t.register\",\n",
    "    input=\"viewsheds\",\n",
    "    maps=\",\".join(maps),\n",
    "    start=1,\n",
    "    unit=\"minutes\",\n",
    "    increment=1,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's print basic dataset info. We will use this info later on to set computational region covering the entire dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "info = gs.parse_command(\"t.info\", input=\"viewsheds\", flags=\"g\")\n",
    "pd.DataFrame(info.values(), index=info.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To list the individual rasters, we will use t.rast.list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv(\n",
    "    io.StringIO(\n",
    "        gs.read_command(\n",
    "            \"t.rast.list\",\n",
    "            input=\"viewsheds\",\n",
    "            separator=\"comma\",\n",
    "            columns=\"name,start_time\",\n",
    "        )\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can quickly get basic statistics such as the size of the viewsheds (see _sum_ column for the number of visible cells):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\n",
    "    io.StringIO(gs.read_command(\"t.rast.univar\", input=\"viewsheds\", separator=\"comma\"))\n",
    ")\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's find and visualize largest and smallest viewshed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "largest = df.iloc[df[[\"sum\"]].idxmax()[\"sum\"]].id\n",
    "smallest = df.iloc[df[[\"sum\"]].idxmin()[\"sum\"]].id\n",
    "\n",
    "viewshed_map = gj.Map(saved_region=\"umstead_drive_region\")\n",
    "viewshed_map.d_rast(map=\"ortho\")\n",
    "viewshed_map.d_rast(map=largest, values=1)\n",
    "viewshed_map.d_rast(map=smallest, values=1)\n",
    "viewshed_map.d_vect(map=\"umstead_drive\", color=\"white\")\n",
    "viewshed_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compute a temporal dataset where values of each viewshed will represent the registered start time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use temporal raster algebra. Here we compute a new temporal dataset _viewsheds_start_ so that for example viewshed with start time 5 has value 5 for visible area and no data for invisible area."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\n",
    "    \"t.rast.mapcalc\",\n",
    "    inputs=\"viewsheds\",\n",
    "    output=\"viewsheds_start\",\n",
    "    basename=\"viewshed_start\",\n",
    "    expression=\"if (viewsheds == 0, null(), start_time())\",\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Set color of the newly computed time series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\"t.rast.colors\", input=\"viewsheds_start\", color=\"plasma\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With TimeSeriesMap, we can interactively visualize the time series:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "timemap = gj.TimeSeriesMap(width=800)\n",
    "timemap.d_rast(map=\"ortho\")\n",
    "timemap.d_vect(map=\"umstead_drive\")\n",
    "timemap.add_raster_series(\"viewsheds_start\")\n",
    "timemap.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can export an animated GIF:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "\n",
    "Image(timemap.save(\"animation.gif\", duration=300))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cumulative viewshed\n",
    "We can compute the cumulative viewshed, which aggregates viewsheds from multiple viewpoints. In this way you can e.g., identify the most frequently visible areas from the road.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since our viewshed rasters are binary (0 invisible, 1 visible), we will use r.series method *sum*. Then we replace zeros with no data using r.null and set a new color ramp:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cumulative viewshed\n",
    "gs.run_command(\"r.series\", input=maps, output=\"cumulative_viewshed\", method=\"sum\")\n",
    "gs.run_command(\"r.null\", map=\"cumulative_viewshed\", setnull=0)\n",
    "gs.run_command(\"r.colors\", map=\"cumulative_viewshed\", color=\"plasma\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's visualize the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cumulative_map = gj.InteractiveMap()\n",
    "cumulative_map.add_raster(\"cumulative_viewshed\", opacity=0.8)\n",
    "cumulative_map.add_vector(\"umstead_drive\")\n",
    "cumulative_map.add_layer_control(position=\"bottomright\")\n",
    "cumulative_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And create a 3D rendering with draped cumulative viewshed over the DSM:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map3d = gj.Map3D()\n",
    "map3d.render(\n",
    "    elevation_map=\"dsm\",\n",
    "    resolution_fine=1,\n",
    "    color_map=\"cumulative_viewshed\",\n",
    "    vline=\"umstead_drive\",\n",
    "    vline_width=3,\n",
    "    vline_color=\"white\",\n",
    "    light_brightness=50,\n",
    "    position=[0.4, 0.8],\n",
    "    height=3000,\n",
    "    perspective=10,\n",
    ")\n",
    "map3d.overlay.d_legend(\n",
    "    raster=\"cumulative_viewshed\", at=(0, 30, 1, 7), use=[1, 2, 3, 4, 5, 6], flags=\"fb\"\n",
    ")\n",
    "map3d.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mask\n",
    "Now let's compute Excess Green Index (ExGI, [Woebbecke et al.](https://elibrary.asabe.org/abstract.asp?aid=27838)) from orthophoto and analyze its distribution within the visible area."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute ExGI using raster algebra:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\"r.rgb\", input=\"ortho\", red=\"red\", green=\"green\", blue=\"blue\")\n",
    "gs.mapcalc(\"exgi = (2.0 * green - red - blue)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ndvi_map = gj.Map()\n",
    "ndvi_map.d_rast(map=\"exgi\")\n",
    "ndvi_map.d_legend(raster=\"exgi\", flags=\"t\")\n",
    "ndvi_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will mask the data by the visible area:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\"r.mask\", raster=\"cumulative_viewshed\")\n",
    "data = gs.parse_command(\"r.univar\", map=\"exgi\", flags=\"g\")\n",
    "print(\n",
    "    f\"Average ExGI of visible cells: {float(data['mean']):.2f} ± {float(data['stddev']):.2f}\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ndvi_map = gj.Map()\n",
    "ndvi_map.d_rast(map=\"exgi\")\n",
    "ndvi_map.d_legend(raster=\"exgi\", flags=\"t\")\n",
    "ndvi_map.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see the histogram of visible ExGI using d.histogram:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "histo = gj.Map(width=800, height=400)\n",
    "histo.d_histogram(map=\"exgi\", bgcolor=\"#EAEAF2\")\n",
    "histo.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read as numpy array\n",
    "It is also easy to use the results as a numpy array and then use other Python libraries to analyze the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "exgi = gs.array.array(mapname=\"exgi\", null=\"nan\")\n",
    "exgi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_style(\"darkgrid\")\n",
    "sns.histplot(exgi.ravel(), kde=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, remove the mask:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command(\"r.mask\", flags=\"r\")"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}