geosciences-250279.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**[An Automatic Procedure for the Quantitative Characterization of Submarine Bedforms](http://www.mdpi.com/2076-3263/8/1/28/htm)**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Abstract**\n",
    "\n",
    "\n",
    "A model for the extraction and quantitative characterization of submarine landforms from high-resolution digital bathymetry is presented. The procedure is fully automated and comprises two parts. The first part consists of an analytical model which extracts quantitative information from a Digital Elevation Model in the form of objects with similar parametric characteristics (terrain objects). The second part is a rule-based model where the terrain objects are reclassified into distinct landforms with well-defined three dimensional characteristics. For the focus of this work, the quantitative characterization of isolated dunes (height greater than 2 m) is used to exemplify the process.\n",
    "The primary metrics used to extract terrain objects are the flatness threshold and the search radius, which are then used by the analytical model to identify the feature type. Once identified as dunes, a sequence of spatial analysis routines is applied to identify and compute metrics for each dune including length, height, width, ray of curvature, slope analysis for each stoss and lee side, and dune symmetry. \n",
    "Dividing the model into two parts, one scale-dependent and another centered around the shape of the landform, makes the model applicable to other submarine landforms like ripples, mega-ripples, and coral reefs, which also have well-defined three-dimensional characteristics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!g.remove -f type=raster name=bathy_2015_el"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!rm -rf /tmp/UTM*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Keywords:** geomorphometry; GIS; spatial scale; spatial analysis; terrain analysis;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **GRASS GIS (Version 7.2) with the following `GRASS GIS ADDONS` installed via [`g.extension`](https://grass.osgeo.org/grass72/manuals/g.extension):**\n",
    "    * [`r.geomorphon`](https://grass.osgeo.org/grass74/manuals/addons/r.geomorphon.html)\n",
    "    * [`r.area`](https://grass.osgeo.org/grass74/manuals/addons/r.area.html)\n",
    "    * [`v.transects`](https://grass.osgeo.org/grass74/manuals/addons/v.transects.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime as dt\n",
    "start=dt.datetime.now()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import grass.script as gs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from grass_session import Session\n",
    "from grass.script import core as gcore\n",
    "import grass.script.setup as gsetup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipygrass.grender import makefigure, makemap, makelegend\n",
    "from ipygrass.gisutils import grouper, list2table, list2dict, getcoords, getprofile\n",
    "from ipygrass.grassutil import General as g\n",
    "from ipygrass.grassutil import Raster as r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Get the bathymetry data**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "url = 'https://ndownloader.figshare.com/files/15008201'\n",
    "import urllib.request\n",
    "urllib.request.urlretrieve(url, filename='/tmp/bathy_2015.tif')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Import the data**\n",
    "\n",
    "    * `GRASS GIS` command: [`r.in.gdal`](https://grass.osgeo.org/grass74/manuals/r.in.gdal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "with Session(gisdb='/tmp', \n",
    "             location='UTM19N',\n",
    "             mapset='PERMANENT',\n",
    "             create_opts='/tmp/bathy_2015.tif'):\n",
    "                 print(gcore.parse_command(\"g.gisenv\", flags=\"s\"))\n",
    "                 gs.run_command('r.in.gdal',\n",
    "                               input='/tmp/bathy_2015.tif',\n",
    "                               output='bathy_2015',\n",
    "                               flags=\"oe\")\n",
    "                 gs.run_command('g.region', flags='ap')\n",
    "\n",
    "session = gsetup.init(\n",
    "    '/tmp', \n",
    "    'UTM19N', \n",
    "    'PERMANENT')\n",
    "\n",
    "gs.run_command('r.in.gdal', \n",
    "                  input='/tmp/bathy_2015.tif', \n",
    "                  output='bathy_2015', \n",
    "                  flags='oe', \n",
    "                  overwrite=True)\n",
    "\n",
    "g.read_command('g.region', \n",
    "                   raster='bathy_2015',\n",
    "                   flags='ap', htable=True, sep=':')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Set the colortable to `haxby` with histogram equalization**\n",
    "\n",
    "    * `GRASS GIS` command: [`r.colors`](https://grass.osgeo.org/grass74/manuals/r.colors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.colors', color='haxby', map='bathy_2015', flags='e')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makelegend(raster='bathy_2015', fontsize=8, units=' m', label='Bathy 2015')\n",
    "makefigure(['bathy_2015'],\n",
    "           caption=[1, 'MBES 2015, cell size: $1 \\\\times 1 \\\\ [m]$'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#uncomment to run an ipyleaflet widget# makemap(['bathy_2015'], zoom=15, caption=[1,'$\\\\text{MBES 2015}$'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#makemap(['bathy_2015'], zoom=15, caption=[1,'$\\\\text{MBES 2015}$'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **Set the `GRASS GIS` working region to the extent of the control unit #1 (visually identified sand dune)**\n",
    "\n",
    "```\n",
    "north:      4546380\n",
    "south:      4546202\n",
    "west:       506185\n",
    "east:       506571\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.read_command('g.region', \n",
    "                   n=4546380, \n",
    "                   s=4546202,\n",
    "                   w=506185,\n",
    "                   e=506571,\n",
    "                   flags='ap', htable=True, sep=':')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['bathy_2015'], \n",
    "           caption=[2, \n",
    "                    'Control unit #1, cell size: $1 \\\\times 1 \\\\ [m]$'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GIS Rule based Model-GRM\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The whole GRM workflow can be divided into three sections:\n",
    "1. Extract and vectorize sand wave crest (SWC).\n",
    "2. Extract and vectorize sand wave main body (SW).\n",
    "3. Identify lee and stoss side and compute sand wave’s metrics.\n",
    "\n",
    "The sequence of each step are summarized and visually described below:\n",
    "\n",
    "## Extract and vectorize sand wave crest for each bedform\n",
    "\n",
    "###  Extraction of sand wave crest (SWC) \n",
    "From the TFE results (r.geomorphon), SWC are identified by extracted by reclassifying the cells with feature type equal to ridge and summit (feature type class: 2,3) into a new raster feature with category value 1 and setting the remaining cells to null (Figure 7)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.geomorphon', \n",
    "                  elevation='bathy_2015',\n",
    "                  forms='geomorphometry',\n",
    "                  search=9,\n",
    "                  skip=3,\n",
    "                  flat=2.0,\n",
    "                  dist=0, \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.mapcalc' , \n",
    "                  expression = '%s=if(%s==3 | %s==2,1, null())' % ('swc','geomorphometry', 'geomorphometry'), \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['geomorphometry', \n",
    "            'swc'], \n",
    "           caption=[7, 'Extraction of sand wave crest (SWC).'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SWC thinning\n",
    "SWC areas are thinned and reduced to a single pixel width (Figure 8)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.thin', \n",
    "                  input='swc',\n",
    "                  output='swc_thin',\n",
    "                  iterations=400,\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['swc', \n",
    "            'swc_thin'], \n",
    "           caption=[8, 'SWC thinning.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SWC clumping\n",
    "Each SWC is recategorized by grouping cells that form physically discrete areas into unique categories and assign a distinct color to each raster feature, different colors are assigned to each linear feature (Figure 9)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.clump',\n",
    "                  input='swc_thin',\n",
    "                  output='swc_thin_clump',\n",
    "                  flags='d',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['swc_thin', \n",
    "            'swc_thin_clump'], \n",
    "           caption=[9, 'SWC clumping.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SWC filtering by length\n",
    "Each feature with same category shorter than a given threshold is removed (Figure 10)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.area', \n",
    "                  input='swc_thin_clump', \n",
    "                  output='swc_thin_long',\n",
    "                  lesser=70,\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['swc_thin_clump', \n",
    "            'swc_thin_long'], \n",
    "           caption=[10, 'SWC filtering by length.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SWC vectorization \n",
    "Conversion from raster to vector to obtain a vector feature of type line representing an approximate sand wave crest (Figure 11)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.to.vect', \n",
    "                  input='swc_thin_long', \n",
    "                  output='swc_thin_long_v',\n",
    "                  type='line',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['swc_thin_long', \n",
    "            'swc_thin_long_v'], \n",
    "           caption=[11, 'SWC vectorization.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SWC topological cleaning\n",
    "Line features are cleaned by removing any dangle (Figure 12)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('v.generalize', \n",
    "                  input='swc_thin_long_v', \n",
    "                  output='swc_thin_long_smooth_v',\n",
    "                  method='douglas',\n",
    "                  threshold=2,\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['swc_thin_long_v', \n",
    "            'swc_thin_long_smooth_v'], \n",
    "           caption=[12, 'SWC topological cleaning.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SWC smoothing\n",
    "A low pass filter is used to obtain a vectorized Sand Wave Crest (Figure 13)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('v.clean', \n",
    "                  input='swc_thin_long_smooth_v', \n",
    "                  output='swc_thin_long_smooth_clean_v',\n",
    "                  type='line',\n",
    "                  tool='rmdangle,rmdangle,rmdangle,rmdangle',\n",
    "                  threshold='5,10,20,30',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['swc_thin_long_smooth_v', \n",
    "            'swc_thin_long_smooth_clean_v'], \n",
    "           caption=[13, 'SWC smoothing.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identify areas covered by large scale bedforms\n",
    "\n",
    "###  Sand wave (SW) extraction\n",
    "From the TFE results (r.geomorphon), the entire landform is extracted by reclassifying the cells with feature type equal to summit, ridge, spur, and slope (feature type: class 2, 3, 5, 6) into a new raster feature with category value 1, and setting the remaining cells to null (Figure 14)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.read_command('g.region', \n",
    "                   n=4546380, \n",
    "                   s=4546202,\n",
    "                   w=506185,\n",
    "                   e=506571,\n",
    "                   flags='ap', htable=True, sep=':')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.geomorphon', \n",
    "                  elevation='bathy_2015', \n",
    "                  forms='geomorphometry_sw', \n",
    "                  search=30, \n",
    "                  skip=7, \n",
    "                  flat=3.8, \n",
    "                  dist=15, \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.mapcalc' , \n",
    "                  expression=\"sw=if(%s==3 | %s==2 | %s==6 | %s==5 , 1, null())\" % ('geomorphometry_sw', \n",
    "                                                                                   'geomorphometry_sw', \n",
    "                                                                                   'geomorphometry_sw', \n",
    "                                                                                   'geomorphometry_sw'), \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['geomorphometry_sw', \n",
    "            'sw'], \n",
    "           caption=[14, 'Sand wave (SW) extraction.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SW clumping\n",
    "The SW raster map is recategorized by grouping cells that form physically discrete areas into unique categories and assign a distinct color to each raster feature (Figure 15)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.clump', \n",
    "                  input='sw',\n",
    "                  output='sw_clump',\n",
    "                  flags='d',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw', \n",
    "            'sw_clump'], \n",
    "           caption=[15, 'SW clumping.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SW filtering by area\n",
    "Each raster feature is reclassified based on its area, all the features having an area smaller than a given threshold are removed (Figure 16)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.area', \n",
    "                  input='sw_clump',\n",
    "                  output='sw_clean',\n",
    "                  lesser=1000,\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_clump', \n",
    "            'sw_clean'], \n",
    "           caption=[16, 'SWC filtering by area.'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# makemap(['sw_clean'], zoom=15, caption=[1,'$\\\\text{MBES 2015}$'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SW filling\n",
    "Null cells within the discrete areas are filled with the same category of the surrounding pixels (Figure 17)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.neighbors', \n",
    "                  input='sw_clean', \n",
    "                  output='sw_clean_fill3', \n",
    "                  method='maximum',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_clean', \n",
    "            'sw_clean_fill3'], \n",
    "           caption=[17, 'SW filling.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SW vectorization\n",
    "Conversion from raster to vector to obtain a vector feature of type polygon representing an approximate sand wave body (Figure 18)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.read_command('g.region', \n",
    "                   n=4546380, \n",
    "                   s=4546202,\n",
    "                   w=506185,\n",
    "                   e=506571,\n",
    "                   flags='apl', htable=True, sep=':')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.to.vect', \n",
    "                  input='sw_clean_fill3', \n",
    "                  output='sw_clean_fill3_v', \n",
    "                  type='area',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('v.clean', \n",
    "                  input='sw_clean_fill3_v',\n",
    "                  output='sw_clean_fill3_v_clean',\n",
    "                  tool='rmarea',\n",
    "                  threshold=10,\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_clean_fill3', \n",
    "            'sw_clean_fill3_v_clean'], \n",
    "           caption=[18, 'SW vectorization.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Identify lee and stoss side\n",
    "\n",
    "###  SW and SWC overlay \n",
    "The vectorized sand wave crest is overlaid on top of the polygonal area representing the sand wave body (Figure 19)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_clean_fill3_v_clean', \n",
    "            'swc_thin_long_smooth_clean_v'], \n",
    "           caption=[19, 'SW and SWC overlay.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SWC clipping\n",
    "The portion of the sand wave crest that is not included in the sand wave body is removed (Figure 20)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('v.overlay', \n",
    "                  ainput='swc_thin_long_smooth_clean_v', \n",
    "                  atype='line', \n",
    "                  binput='sw_clean_fill3_v_clean', \n",
    "                  out='sw_ridges_v', \n",
    "                  operator='and', \n",
    "                  olayer='0,1,0',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_clean_fill3_v_clean', \n",
    "            'sw_ridges_v'], \n",
    "           caption=[20, 'SWC clipping.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SWC buffering\n",
    "A polygonal area is created by buffering the sand wave crest (buffer distance equal to the DBM cell size) (Figure 21)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('v.buffer', \n",
    "                  input='sw_ridges_v', \n",
    "                  output='sw_buffer_v', \n",
    "                  distance=1, \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_ridges_v', \n",
    "            'sw_buffer_v'], \n",
    "           caption=[21, 'SWC buffering.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  SW splitting\n",
    "The buffered sand wave crest is used to split the sand wave body into two parts (Figure 22)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('v.overlay', \n",
    "                  ainput='sw_clean_fill3_v_clean', \n",
    "                  binput='sw_buffer_v', \n",
    "                  operator='not', \n",
    "                  output='sw_splitted_v', \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_clean_fill3_v_clean', \n",
    "            'sw_splitted_v'], \n",
    "           caption=[22, 'SW splitting.'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identification of stoss and lee sides\n",
    "The identification is achieved by performing an univariate statistical analysis on the DBM slope, using each sand wave side as a mask. The side with the higher values of the slope is assigned the label of lee side and is colored in grey, while the side with the lower values of the slope is assigned the label of stoss side (Figure 23)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('v.colors', \n",
    "                  map='sw_splitted_v',\n",
    "                  use='cat',\n",
    "                  color='random')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_clean_fill3_v_clean', \n",
    "            'sw_splitted_v'], \n",
    "           caption=[23,'Identification of dune\\'s side.'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('v.to.rast', \n",
    "                  input='sw_splitted_v', \n",
    "                  output='sw_splitted', \n",
    "                  type='area', use='cat', overwrite=True)\n",
    "                  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_splitted', \n",
    "            'sw_splitted_v'], \n",
    "           caption=[18, 'SW vectorization.'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.run_command('r.slope.aspect',\n",
    "                  elevation='bathy_2015',\n",
    "                  slope='bathy_2015_slope_deg',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stats = g.read_command('r.univar', \n",
    "                  map='bathy_2015_slope_deg', \n",
    "                  zones='sw_splitted', \n",
    "                  flags='ge',\n",
    "                  overwrite=True, sep='=')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "side_a, side_b = g.read_multifeature(stats, htable=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "display(side_a, side_b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if side_a['mean'] > side_b['mean']:\n",
    "    print(side_a['zone'], 'is lee side')\n",
    "    !v.db.update sw_splitted_v column=a_label value=lee where=\"cat={side_a['zone']}\"\n",
    "    !v.db.update sw_splitted_v column=a_label value=stoss where=\"cat={side_b['zone']}\"\n",
    "else: \n",
    "    print(side_b['zone'], 'is lee side')\n",
    "    !v.db.update sw_splitted_v column=a_label value=lee where=\"cat={side_b['zone']}\"\n",
    "    !v.db.update sw_splitted_v column=a_label value=stoss where=\"cat={side_a['zone']}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.read_command('v.db.select', map='sw_splitted_v').strip().split('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Compute sand wave’s metrics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SW Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.build.polylines',\n",
    "                  type='line',\n",
    "                  input='sw_ridges_v',\n",
    "                  output='sw_ridges_v_poliline',\n",
    "                  cats='no', \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.category', \n",
    "                  option='add',\n",
    "                  type='line',\n",
    "                  input='sw_ridges_v_poliline',\n",
    "                  output='sw_ridges_v_polilineCAT', \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.db.addtable',\n",
    "                  map='sw_ridges_v_polilineCAT',\n",
    "                  layer=1,\n",
    "                  columns='Length double precision')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.to.db',\n",
    "                  type='line',\n",
    "                  layer=1,\n",
    "                  map='sw_ridges_v_polilineCAT',\n",
    "                  option='cat',\n",
    "                  columns='cat',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.to.db',\n",
    "                  type='line',\n",
    "                  layer=1,\n",
    "                  units='meters',\n",
    "                  map='sw_ridges_v_polilineCAT',\n",
    "                  option='length',\n",
    "                  columns='Length',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.read_command('v.db.select',\n",
    "                   map='sw_ridges_v_polilineCAT', \n",
    "                   separator=',', sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SWC 3D length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.split',\n",
    "                  input='sw_ridges_v_polilineCAT',\n",
    "                  output='sw_ridges_v_polilineCAT_split',\n",
    "                  length=1,\n",
    "                  flags='f', \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.to.points',\n",
    "                  input='sw_ridges_v_polilineCAT_split',\n",
    "                  output='sw_ridges_v_polilineCAT_splitP',\n",
    "                  dmax=1, \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.db.droptable', \n",
    "                  flags='f', \n",
    "                  map='sw_ridges_v_polilineCAT_splitP',\n",
    "                  layer=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.db.droptable', \n",
    "                  flags='f', \n",
    "                  map='sw_ridges_v_polilineCAT_splitP',\n",
    "                  layer=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.db.addtable', \n",
    "                  map='sw_ridges_v_polilineCAT_splitP', \n",
    "                  layer=2, \n",
    "                  columns='x DOUBLE PRECISION, y DOUBLE PRECISION, z DOUBLE PRECISION')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.to.3d',\n",
    "                  input='sw_ridges_v_polilineCAT_splitP',\n",
    "                  output='sw_ridges_v_polilineCAT_splitP3D',\n",
    "                  type='point', \n",
    "                  column='z', \n",
    "                  layer=2,\n",
    "                  overwrite=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.drape', \n",
    "                  input='sw_ridges_v_polilineCAT_splitP3D', \n",
    "                  output='sw_ridges_v_polilineCAT_splitP3D_draped', \n",
    "                  elevation='bathy_2015',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.to.db', \n",
    "                  type='point', \n",
    "                  layer=2, \n",
    "                  map='sw_ridges_v_polilineCAT_splitP3D_draped', \n",
    "                  option='coor', \n",
    "                  columns='x,y,z',\n",
    "                  overwrite=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp = g.read_command('v.db.select',\n",
    "                    map='sw_ridges_v_polilineCAT_splitP3D_draped', \n",
    "                    layer=2, \n",
    "                    separator=',', \n",
    "                    std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.spatial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matx = np.array([float(i.split(',')[1]) for i in dp[1:]])\n",
    "maty = np.array([float(i.split(',')[2]) for i in dp[1:]])\n",
    "matz = np.array([float(i.split(',')[3]) for i in dp[1:]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pp = np.array([list(i) for i in zip(matx, maty, matz)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist = scipy.spatial.distance.cdist(pp, pp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Distance between endpoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3D Distance along the line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist.diagonal(1).sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SW height\n",
    "Derivation of SW height by generating a series of vertical profiles along several transects perpendicular to SWC. The spacing between the equidistant vertical profiles is given by an input parameter and set to 10 m as default value, the length of each profile is also variable by the user (by default is set to be the same length of the sand wave ridge) (Figure 24)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.transects', \n",
    "                  input='sw_ridges_v', \n",
    "                  output='sw_ridges_transect_v', \n",
    "                  transect_spacing=1, \n",
    "                  dleft=70, \n",
    "                  dright=70, \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_splitted_v', \n",
    "            'sw_ridges_transect_v'], \n",
    "           caption=[24, 'Generate transects to be used as vertical profiles.'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines = gs.read_command('v.out.ascii', \n",
    "                           input='sw_ridges_transect_v', \n",
    "                           output='-', \n",
    "                           type='line', \n",
    "                           format='standard', \n",
    "                           overwrite=True).strip().split('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines = g.read_command('v.out.ascii', \n",
    "                           input='sw_ridges_transect_v', \n",
    "                           output='-', \n",
    "                           type='line', \n",
    "                           format='standard', \n",
    "                           overwrite=True, sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coords = getcoords(lines)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc = [{'layer': 'bathy_2015', \n",
    "       'resolution': 1,\n",
    "       'coordinates': v} for i,v in coords.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from multiprocessing import Pool\n",
    "\n",
    "prof = []\n",
    "with Pool(8) as p:\n",
    "    prof.append(p.map(r.makeprofiles, cc))\n",
    "\n",
    "pr = []\n",
    "with Pool(8) as p:\n",
    "    pr.append(p.map(getprofile, prof[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,4))\n",
    "plt.grid(True)\n",
    "for i in pr[0]:\n",
    "    plt.plot(i[:,2], i[:,3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dz = [float(np.abs(np.min(i[:,3])) - np.abs(np.max(i[:,3]))) for i in pr[0]]\n",
    "H = max(dz)\n",
    "H"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vertical Profile"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zc = pr[0][np.argmax(dz)][:,3]\n",
    "dc = pr[0][np.argmax(dz)][:,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,4))\n",
    "plt.grid(True)\n",
    "plt.plot(dc,zc,'-');\n",
    "plt.ylabel('Depth [m]')\n",
    "plt.xlabel('Distance [m]');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = pr[0][np.argmax(dz)][np.argmax(pr[0][np.argmax(dz)][:,3]),0]\n",
    "y = pr[0][np.argmax(dz)][np.argmax(pr[0][np.argmax(dz)][:,3]),1]\n",
    "z = pr[0][np.argmax(dz)][np.argmax(pr[0][np.argmax(dz)][:,3]),3]\n",
    "h = max(dz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z,h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SW Width\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "W = h*np.tan(float(side_a['mean'])) + h*np.tan(float(side_b['mean']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "W"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SWC Validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SWC reconstruction and matching"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xc = [i[np.argmax(i[:,3]), 0] for i in pr[0]]\n",
    "yc = [i[np.argmax(i[:,3]), 1] for i in pr[0]]\n",
    "zc = [i[np.argmax(i[:,3]), 3] for i in pr[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(12,4))\n",
    "plt.grid(True)\n",
    "plt.plot(xc,yc,'o')\n",
    "plt.plot(x,y,'or');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xyz = [i for i in map(lambda x: str(x).replace('(','').replace(')','').replace(' ',''), zip(xc,yc,zc))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('/tmp/t.csv', 'w') as t:\n",
    "    for i in xyz:\n",
    "        t.write(i)\n",
    "        t.write('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "gs.run_command('v.in.ascii', \n",
    "                  input='/tmp/t.csv', \n",
    "                  output='crest_point', \n",
    "                  separator=',', \n",
    "                  format='point', \n",
    "                  columns=\"x double precision, y double precision, z double precision\",\n",
    "                  z=3,\n",
    "                  flags='z', \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "makefigure(['sw_splitted_v', \n",
    "            'crest_point'], \n",
    "           caption=[24, 'Generate transects to be used as vertical profiles.'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.db.addtable', \n",
    "                  map='crest_point', \n",
    "                  table='crest_point', \n",
    "                  columns=\"dist double precision, dist2 double precision\", \n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gs.run_command('v.db.connect', \n",
    "                  map='crest_point', \n",
    "                  table='crest_point', \n",
    "                  flags='p',\n",
    "                  overwrite=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#grass.run_command('v.distance', from='crest_point', to='sw_ridges_v', upload='dist', column='dist')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#grass.run_command('v.distance',\n",
    "#                  from='crest_point',\n",
    "#                  to='swc_thin_long_v',\n",
    "#                  upload='dist',\n",
    "#                  column='dist2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!v.distance from=crest_point to=sw_ridges_v upload=dist column=dist --qq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!v.distance from=crest_point to=swc_thin_long_v upload=dist column=dist2 --qq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist = g.read_command('v.db.select', \n",
    "                          map='crest_point', std=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "distance1 = [i.split(\"|\")[1] for i in dist[1:]]\n",
    "distance2 = [i.split(\"|\")[2] for i in dist[1:]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mean displacements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(distance1, np.dtype(float)).mean(), np.array(distance1, np.dtype(float)).std() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(distance2, np.dtype(float)).mean(), np.array(distance2, np.dtype(float)).std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load custom ccs (not run)\n",
    "```python\n",
    "from IPython.core.display import HTML\n",
    "\n",
    "\n",
    "def css_styling():\n",
    "    styles = open(\"custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()\n",
    "``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "end=dt.datetime.now()\n",
    "elapsed=end-start\n",
    "elapsed.seconds\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": true,
   "latex_user_defs": true,
   "report_style_numbering": false,
   "user_envs_cfg": true
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Outline",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "383px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "position": {
    "height": "438px",
    "left": "814px",
    "right": "20px",
    "top": "148px",
    "width": "355px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}