Visual analyisis of geothermal probes with pydeck.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "<h1 style=\"text-align: center;  font-weigth: bold; margin-top: 20px;\">\n",
    "  Visual exploratory data analysis with python and pydeck\n",
    "</h1>\n",
    "<h2 style=\"text-align: center; margin-bottom: 10px;\">\n",
    "  Lorenzo Perozzi\n",
    "</h2>\n",
    "<p style=\"text-align: center; margin-bottom: 20px;\">\n",
    "   <a href=\"https://www.unige.ch/ge-rgba/welcome/\">GE-RGBA Group, Departement of Earth Science, University of Geneva</a>\n",
    "</p>\n",
    "<div align=\"center\" style=\"margin-bottom: 20px;\">\n",
    "    <img src=\"src/logo.png\" style=\"height: 70px\">\n",
    "</div>\n",
    "\n",
    "\n",
    " \n",
    "## About\n",
    "\n",
    "During this tutorial, it will be shown how to use python to process and visualize a dataset about geothermal probes availability in the Canton of Geneva. This dataset can be obtained (open access) through the <a href=\"https://ge.ch/sitg/fiche/6867 \">SITG</a> (Système d’Information du Territoire à Genève). We will cover these a spects:\n",
    "\n",
    "- Load the geothermal probes dataset.\n",
    "- Convert CRS coordinate system with **pyproj**\n",
    "- Extract depth information form attributes\n",
    "- Visualising the results with **pydeck**\n",
    "\n",
    "|         | Info |\n",
    "|--------:|:-----|\n",
    "| When | Friday, October 1st • 12:30 - 13:00  |\n",
    "| Live stream | Registration mandatory - [Under this link](https://formulaire.unige.ch/outils/limesurvey3/index.php/268393?lang=fr)  |\n",
    "| conda environment  | `DST-geothermal-visual` |\n",
    "| Deck.gl documentation | https://deck.gl/ |\n",
    "\n",
    "\n",
    "## Setup\n",
    "\n",
    "If you want to follow along the tutorial, make sure you've done these steps **before the tutorial begin**:\n",
    "\n",
    "### Step 1\n",
    "\n",
    "**Install a Python distribution:**\n",
    "\n",
    "In this tutorial we will be using the [Anaconda](https://www.anaconda.com/)\n",
    "Python distribution along with the `conda` package manager. If you already have\n",
    "Anaconda or Miniconda installed, you can skip this step.\n",
    "\n",
    "If not, please follow the instructions for getting Anaconda up and running in\n",
    "your system: https://docs.anaconda.com/anaconda/install/\n",
    "\n",
    "### Step 2\n",
    "\n",
    "**Create the `DST-geothermal-visual` conda environment:**\n",
    "\n",
    "1. Clone [this](https://github.com/geoenergy/DST1_pydeck_visual) repository;\n",
    "1. Open a terminal (*Anaconda Prompt* if you are running Windows). The\n",
    "   following steps should be done in the terminal;\n",
    "1. Navigate to the folder that has been cloned\n",
    "   (if you don't know how to do this, take a moment to read [the Software\n",
    "   Carpentry lesson on the Unix shell](http://swcarpentry.github.io/shell-novice/));\n",
    "1. Create the conda environment by running `conda create -n DST-geothermal-visual`\n",
    "   (this will download and install all of the packages used in the tutorial); \n",
    "1. **Windows users:** Make sure you set a default browser that is **not Internet Explorer**;\n",
    "1. Installing `pip` in the new environment: `conda install -n DST-geothermal-visual pip`;\n",
    "1. Activate the conda environment: `conda activate DST-geothermal-visual`;\n",
    "1. Installing packages to run the tutorial: `pip install ipython pandas numpy matplotlib pyproj pydeck jupyterlab`;\n",
    "1. Create a new kernel for this environment environment: `ipython kernel install --user --name=DST-geothermal-visual`;\n",
    "1. Start the JupyterLab server: `jupyter lab`;\n",
    "1. Open the `Visual analyisis of geothermal probes with pydeck.ipynb` to follow the tutorial or a new fresh Notebook if you want to start form scratch. Be sure the kernel is set to `DST-geothermal-visual`; \n",
    "1. Feel free to open an issue if you have some problem during the installation or during the tutorial.\n",
    "   \n",
    "   \n",
    "<div style=\"text-align: left; margin-bottom: 100px;\">\n",
    "\n",
    " </div>"
   ],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "NV8tEEYPdOKod1f1cxSO",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     }
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "Importing packages"
   ],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "SSQW4YmPIqnwH2wIUXwK",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     }
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import pydeck\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.cm\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "plt.rcParams['figure.dpi'] = 150"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "IaKSihx1a2UkQNL90mpM",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     },
     "outputId": null
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Load and inspect the geothermal probes dataset\n",
    "The dataset is stored on the [SITG](https://ge.ch/sitg/fiche/6867) (Système d'information du territoire à Genève) and publicly available. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "filename = 'data/CTSS_CHAUFFAGE_SONDE.csv'"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "Gb5pHJpXGsST51EwAZ1v",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     },
     "outputId": null
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "To open the dataset we use the [`Pandas`](https://pandas.pydata.org/docs/) package. By default in a `csv` file, columns are separated by a comma `,`, however, we can specify which method is used to spearate the columns. Since the columns in this files are separated by a semicolon, we need to specify the `sep` arguments in the `pd.read_csv` class."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes = pd.read_csv(filename, encoding='latin-1', sep=';')"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "2AQHu1DJaf21DX11NAV2",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 2
     },
     "outputId": null
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "We can inspect the dataset. For example we can inspect the first 5 lines of the file"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes.head(5)"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "jOOV1VgCaiFK7xHqH4wM",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 2
     },
     "outputId": {
      "block": "j3PDbIPoghRZuAGCUn76",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 2
     }
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "By using the `.info()` methods we can retrieve more details about the dataset such as the total number of rows and columns, the type of the columns and so on."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes.info()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "The file contains 11 columns (attributes) and 2033 entries. The objective here is to analyse/visualize the geothermal probes using `pydeck`, an high-scale spatial rendering powered by [deck.gl](https://deck.gl/#/). We need at least 3 attributes: the spatial coordinates (`X` and `Y`) as well as the depth of each probes.\n",
    "\n",
    "In the dataset the only attributes that do not have `NaN` values are `E` and `N` corresponding to the Easting and Northing coordinates."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes[['E','N']].head(5)\n",
    "# print(tabulate(sondes[['E','N']].head(5), headers='keys', tablefmt='rst'))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "`E` and `N` are in the CH1903+_LV95 reference system (also known as EPSG:2056). \n",
    "To visualize the data with pydeck (and in general with all geospatial visualization packages) however, we need to work on *World Geodetic System 1984 - WGS84* (also know as EPSG:4326).\n",
    "\n",
    "The first step will then to reproject the data from the EPSG:2056 system to the EPSG:4326 system."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Reproject coordinate from EPSG:2056 to EPSG:4326\n",
    "\n",
    "There are several online converters for that such as [EPSG.io](https://epsg.io/), which works well when we have few set of coordinates to transform. However, to be efficient, we use `pyproj` that is a Python interface to [PROJ](https://proj.org/) (cartographic projections and coordinate transformation library)."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from pyproj import Transformer\n",
    "from pyproj import CRS"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "1. Initializing CRS and create a transformer to convert from 2056 to 4326"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "crs_4326 = CRS.from_epsg(4326)\n",
    "crs_2056 = CRS.from_epsg(2056)\n",
    "transformer = Transformer.from_crs(crs_2056, crs_4326)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "2. Convert `E` and `N` to `Latitude` and `Longitude` respectively"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes['lat'], sondes['lon'] = transformer.transform(sondes.E.values, sondes.N.values)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes[['E','N','lat','lon']].head(5)\n",
    "# print(tabulate(sondes[['E','N','lat','lon']].head(5), headers='keys', tablefmt='rst'))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Retrieve depth of geothermal probes\n",
    "\n",
    "We want also know the depth of the geothermal probes. In the dataset we do not have an attribute for that, we need further inspection. Among the 11 columns we have `ALTITUDE_MIN`, `ALTITUDE_MAX` and `DIMENSION` that should give us this information. However these attributes contains several `NaN`. Let's inspect these attributes. \n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION']].sample(8, random_state=51)\n",
    "# print(tabulate(sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION']].sample(8, random_state=51), headers='keys', tablefmt='rst'))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "We have several cases: \n",
    "1. `NaN` everywhere, we will drop these lines while useless\n",
    "1. Depth information contained in the `DIMENSION` attributes, as a string text\n",
    "1. Depth information contained in the (`ALTITUDE_MAX` - `ALTITUDE_MIN`) attributes, as a string text\n",
    "\n",
    "Note: Normally, with `pd.read_csv()` the `NaNs` are automatically detected, however, depending on how the data have been compiled, it is not always the case. For example, the `0.0` value in `ALTITUDE_MAX` or `ALTITUDE_MIN` attribute, corresponds clearly to `NaNs` values. \n",
    "\n",
    "The next step will be to clean up all lines that contains `NaN`.\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes.replace(to_replace=0.0, value=np.NaN, inplace=True)\n",
    "sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION']].sample(8, random_state=51)\n",
    "# print(tabulate(sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION']].sample(8, random_state=51), headers='keys', tablefmt='rst'))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Then we remove all rows with `NaN` in `ALTITUDE_MAX`, `ALTITUDE_MIN`, `DIMENSION`"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes.dropna(subset=['ALTITUDE_MIN', 'ALTITUDE_MAX', 'DIMENSION'], thresh=2, inplace=True)\n",
    "sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION']].sample(8, random_state=51)\n",
    "# print(tabulate(sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION']].sample(8, random_state=51), headers='keys', tablefmt='rst'))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "We then need to create a `DEPTH` attributes that retrieve geothermal probe information from `ALTITUDE_MIN` and `ALTITUDE_MAX`, if these attributes do not contain `NaN`..."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes.reset_index(inplace=True)\n",
    "idx1 = np.where((~np.isnan(sondes['ALTITUDE_MIN'].values)) & (~np.isnan(sondes['ALTITUDE_MAX'].values)))\n",
    "sondes['DEPTH'] = np.nan\n",
    "sondes['DEPTH'].loc[idx1] = sondes.ALTITUDE_MAX - sondes.ALTITUDE_MIN\n",
    "sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION', 'DEPTH']].sample(8, random_state=2)\n",
    "# print(tabulate(sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION','DEPTH']].sample(8, random_state=2), headers='keys', tablefmt='rst'))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "... or from the `DIMENSION` column. This attribute is a string, from which we need to extract depth information. For this we use the following regular expression `str.extract('(\\d+)')` that allow extracting the digits from the last 5 characters of the `DIMENSION` string text."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "idx2 = np.where((np.isnan(sondes['DEPTH'].values)))\n",
    "sondes['DEPTH'].loc[idx2] = sondes['DIMENSION'].loc[idx2].str[-5:].str.extract('(\\d+)', expand=False).astype(np.float32)\n",
    "sondes.dropna(subset=['DEPTH'], inplace=True)\n",
    "sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION', 'DEPTH']].sample(8, random_state=2)\n",
    "# print(tabulate(sondes[['ALTITUDE_MIN','ALTITUDE_MAX','DIMENSION', 'DEPTH']].sample(8, random_state=2), headers='keys', tablefmt='rst'))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Now, we all the information needed to visualize teh geothermal probes dataset with `pydeck`. First we plot an histogram of the `DEPTH` attributes."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "bin = plt.hist(sondes['DEPTH'].values,30)\n",
    "plt.xlabel('Depth [m]')"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "We have both positive values and negative value for `DEPTH`. This means that sometimes `ALTITUDE_MIN` and `ALTITUDE_MAX` have been inverted. We use the `abs` fonction to have positive values everywhere. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sondes['DEPTH'] = sondes['DEPTH'].abs()\n",
    "\n",
    "bin = plt.hist(sondes['DEPTH'].values,30)\n",
    "plt.xlabel('Depth [m]')\n"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "EVBqfCooKW7tUobTG3Rw",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     },
     "outputId": {
      "block": "PwPcZhFYf2EKwAnO38sj",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     }
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Static visual exploration of the geothermal probes depth\n",
    "\n",
    "We can use the `matplotlib` package to plot the coordinates of the probes cmapped bay the depth. The result will be something like this"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "plt.scatter(sondes.lon, sondes.lat, c=sondes.DEPTH)\n",
    "plt.colorbar()\n",
    "plt.xlabel('Longitude')\n",
    "plt.ylabel('Latitude')"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "40NtCGMWNyg8IcHbt9os",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     },
     "outputId": {
      "block": "BWwqNHNIEIM5tq8ozFur",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     }
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "This method gives us some information about the localization and depth, but it is visually difficult to interpret."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Interactive visual exploration using `pydeck`\n",
    "\n",
    "The \"Layer\" is a core concept of deck.gl. A deck.gl layer is a packaged visualization type that takes a collection of datums, associate each with positions, colors, extrusions, etc., and renders them on a map. For this visualization we use a `ColumnnLayer`. Read <a href=\"https://deck.gl/docs/api-reference/layers\" target=\"_blank\">this</a> for a deck.gl layer catalog overview."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "layer = pydeck.Layer(\n",
    "    'ColumnLayer',  # `type` positional argument is here\n",
    "    data=sondes,\n",
    "    get_position=['lon', 'lat'],\n",
    "    auto_highlight=True,\n",
    "    get_elevation='DEPTH',\n",
    "    elevation_scale=25,\n",
    "    radius=50,\n",
    "    pickable=True,\n",
    "    get_fill_color = [69,162,128,255],\n",
    "    coverage=2)\n",
    "\n",
    "view_state = pydeck.ViewState(\n",
    "    longitude=6.183829,\n",
    "    latitude=46.194656,\n",
    "    zoom=10,\n",
    "    min_zoom=5,\n",
    "    max_zoom=15,\n",
    "    pitch=25,\n",
    "    bearing=0)\n",
    "\n",
    "# Combined all of it and render a viewport\n",
    "r = pydeck.Deck(layers=[layer],\n",
    "                height=1500, \n",
    "                initial_view_state=view_state,\n",
    "               )\n",
    "r.to_html('geothermal-probes-viz.html')"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "with some customization ..."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "COLOR_RANGE = [\n",
    "\n",
    "    [49,54,149],\n",
    "    [69,117,180],\n",
    "    [116,173,209],\n",
    "    [171,217,233],\n",
    "    [224,243,248],\n",
    "    [255,255,191],\n",
    "    [254,224,144],\n",
    "    [253,174,97],\n",
    "    [244,109,67],\n",
    "    [215,48,39],\n",
    "    [165,0,38],\n",
    "]\n",
    "\n",
    "\n",
    "BREAKS = [30, 80, 130, 160,  190, 220, 250, 280,310,  340,370]\n",
    "\n",
    "\n",
    "def color_scale(val):\n",
    "    for i, b in enumerate(list(BREAKS)):\n",
    "        if val < b:\n",
    "            return COLOR_RANGE[i]\n",
    "    return COLOR_RANGE[i]\n",
    "\n",
    "sondes[\"fill_color\"] = sondes[\"DEPTH\"].apply(lambda x: color_scale(x))\n"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "ksVZuq4Vg1g2NHoyHDBu",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     },
     "outputId": null
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "layer = pydeck.Layer(\n",
    "    'ColumnLayer',  # `type` positional argument is here\n",
    "    data=sondes,\n",
    "    get_position=['lon', 'lat'],\n",
    "    auto_highlight=True,\n",
    "    get_elevation='DEPTH',\n",
    "    elevation_scale=25,\n",
    "    radius=100,\n",
    "    pickable=True,\n",
    "    get_fill_color = \"fill_color\",\n",
    "\n",
    "    coverage=2)\n",
    "\n",
    "\n",
    "# Set the viewport location\n",
    "view_state = pydeck.ViewState(\n",
    "    longitude=6.183829,\n",
    "    latitude=46.244656,\n",
    "    zoom=10,\n",
    "    \n",
    "    min_zoom=0,\n",
    "    max_zoom=24,\n",
    "    pitch=45,\n",
    "    bearing=0)\n",
    "\n",
    "# Combined all of it and render a viewport\n",
    "r = pydeck.Deck(layers=[layer],\n",
    "                initial_view_state=view_state,\n",
    "                map_style='light'\n",
    "               )\n",
    "r.to_html('geothermal-probes-viz-custom.html', open_browser=False, iframe_height=750)"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "4JufNXO8uByTNCgNy0nx",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 2
     },
     "outputId": {
      "block": "o4t8zrHj2qPvNjDMZYih",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 2
     }
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import pydeck as pdk\n",
    "\n",
    "HEXAGON_LAYER_DATA = (\n",
    "    \"https://raw.githubusercontent.com/visgl/deck.gl-data/master/examples/3d-heatmap/heatmap-data.csv\"  # noqa\n",
    ")\n",
    "\n",
    "# Define a layer to display on a map\n",
    "layer = pdk.Layer(\n",
    "    \"HexagonLayer\",\n",
    "    data=sondes,\n",
    "    get_position=['lon', 'lat'],\n",
    "    auto_highlight=True,\n",
    "    elevation_scale=10,\n",
    "    pickable=True,\n",
    "    elevation_range=[0, 1500],\n",
    "    extruded=True,\n",
    "    radius=500,\n",
    "    coverage=1,\n",
    "    color_range=COLOR_RANGE\n",
    ")\n",
    "\n",
    "\n",
    "# Render\n",
    "r = pydeck.Deck(layers=[layer],\n",
    "                initial_view_state=view_state,\n",
    "#                 map_style='light'\n",
    "                map_style='dark'\n",
    "               )\n",
    "\n",
    "# \n",
    "r.to_html(\"geothermal-probes-viz-hexagon.html.html\",open_browser=False, iframe_height=750)"
   ],
   "outputs": [],
   "metadata": {
    "iooxa": {
     "id": {
      "block": "d4JXmGOilHlp0QoVn2px",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     },
     "outputId": {
      "block": "sQATAoPZSwzDdJ4gBhl2",
      "project": "z95paiOfIhOYRRv5qFO1",
      "version": 1
     }
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "The resulting visualization is a `.html` file that can be opened in any browser (<a href=\"/static/images/visualization/geothermal-probes-viz-custom.html\" target=\"_blank\">click here to show the results in a browser</a>)\n",
    "\n",
    "\n",
    "Data and code to reproduce this work can be found <a href=\"https://github.com/geoenergy/DST1_pydeck_visual\" target=\"_blank\">here.</a>\n",
    "\n",
    "A blog post about this tutorial can be found <a href=\"https://www.geomaap.io/blog/visualization/DST-viz-pydeck\" target=\"_blank\">here.</a>"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {}
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "4fcf223fec717c59157df01c7432a730448faa6bb16368591116d84a611c49ba"
  },
  "iooxa": {
   "id": {
    "block": "wF2kDa0RriEHrJQvocGU",
    "project": "z95paiOfIhOYRRv5qFO1",
    "version": 2
   }
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.6 64-bit ('DST-geothermal-visual': conda)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}