app_update_0825.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PCx4-U8LC9q1"
   },
   "source": [
    "# source code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GpYH-9Tj6pJY"
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import folium\n",
    "from folium import FeatureGroup, LayerControl, Map, Marker\n",
    "import time\n",
    "import datetime\n",
    "import re\n",
    "import pandas as pd \n",
    "\n",
    "CSV_EXTENSION  = 'csv'\n",
    "EXCEL_EXTENSION = 'xls'\n",
    "\n",
    "# NOTE:\n",
    "# TO-DO\n",
    "# 1. test your functions\n",
    "# 2. add docstrings --> check PEP8/google python docstring conventions\n",
    "#      # minimum requirement:\n",
    "#      # inputs and types, functions, return types\n",
    "# 3. after you finish 1 & 2, put all your functions in master/EWBMappy/your_name.py\n",
    "\n",
    "# Jannie\n",
    "class EWBLayer():\n",
    "    \"\"\"\n",
    "    A class to represent a layer on the map.\n",
    "    ...\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    name : str\n",
    "        name of the layer\n",
    "    color : str\n",
    "        color of the layer\n",
    "    df : dataframe\n",
    "        dataframe containing the data of the layer\n",
    "    points : array\n",
    "        array containing tuples of coordinate points of the layer\n",
    "    featureGroup : FeatureGroup\n",
    "        represents a group of points on the map\n",
    "        \n",
    "    Methods\n",
    "    -------\n",
    "    None\n",
    "\n",
    "    \"\"\"\n",
    "    def __init__(self, name, color, df):\n",
    "        \"\"\"\n",
    "        Constructs all the necessary attributes for the EWBLayer object.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        name : str\n",
    "            name of the layer\n",
    "        color : str\n",
    "            color of the layer\n",
    "        df : dataframe\n",
    "            dataframe containing the data of the layer\n",
    "            \n",
    "        \"\"\"\n",
    "        self.name = name\n",
    "        self.color = color\n",
    "        self.df = df\n",
    "        self.points = []\n",
    "        self.featureGroup = FeatureGroup(name=name)\n",
    "\n",
    "# ref: https://github.com/python-visualization/folium/issues/460\n",
    "class EWBMap():\n",
    "    \"\"\"\n",
    "    A class to represent the entire folium map.\n",
    "    ...\n",
    "\n",
    "    Attributes\n",
    "    ----------\n",
    "    layers : array\n",
    "        array of all layers to be shown on this map\n",
    "    map : Map (folium)\n",
    "        map to be displayed\n",
    "    layerNames : array\n",
    "        list of names of layers in the map\n",
    "    \n",
    "    Methods\n",
    "    -------\n",
    "    makeMapfromLayers():\n",
    "        Creates a map from the existing layers.\n",
    "    recenter(string=\"all\"):\n",
    "        Recenter the map around the given points.\n",
    "\n",
    "    \"\"\"\n",
    "    \n",
    "    # Jannie\n",
    "    def __init__(self):\n",
    "        \"\"\"\n",
    "        Constructs all the necessary attributes for the EWBMap object.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        None\n",
    "        \n",
    "        \"\"\"\n",
    "        self.layers = []\n",
    "        self.map = Map(\n",
    "            location=[45.372, -121.6972],\n",
    "            zoom_start=12,\n",
    "            tiles='Stamen Terrain'\n",
    "        )\n",
    "        listOfTiles = ['Stamen Toner', 'openstreetmap']\n",
    "        for tile in listOfTiles:\n",
    "            folium.TileLayer(tile).add_to(self.map) \n",
    "        self.layerNames = []\n",
    "    # Jannie\n",
    "    def makeMapfromLayers(self):\n",
    "        for layer in self.layers:\n",
    "            layer.featureGroup.add_to(self.map)\n",
    "        folium.LayerControl().add_to(self.map)\n",
    "    # Chen\n",
    "    def recenter(self, string = \"all\"):\n",
    "        # center around the town - hardcode location TBD\n",
    "        if string == 'town':\n",
    "            x = 45.5236\n",
    "            y = -122.6750\n",
    "            self.map.location = [x, y]\n",
    "\n",
    "        elif string in self.layerNames:\n",
    "            xMin, xMax, yMin, yMax = [100, -100, 181, -181]\n",
    "            idx = self.layerNames.index(string)\n",
    "            layer = self.layers[idx]\n",
    "            # layer.df[0] - latitutde, layer.df[1] - longitude --> I know this looks ugly\n",
    "            # but is only meant to be a quick fix, will be optimized later\n",
    "            xMin = min(xMin, min(layer.df.iloc[:,0]))\n",
    "            xMax = max(xMax, max(layer.df.iloc[:,0]))\n",
    "            yMin = min(yMin, min(layer.df.iloc[:,1]))\n",
    "            yMax = max(yMax, max(layer.df.iloc[:,1]))\n",
    "            # adjust the map bound according the upper and lower bound of the dataset\n",
    "            self.map.fit_bounds([[xMin, yMin], [xMax, yMax]])\n",
    "        \n",
    "        elif string == 'all':\n",
    "            xMin, xMax, yMin, yMax = [100, -100, 181, -181]\n",
    "            for layer in self.layers:\n",
    "                xMin = min(xMin, min(layer.df.iloc[:,0]))\n",
    "                xMax = max(xMax, max(layer.df.iloc[:,0]))\n",
    "                yMin = min(yMin, min(layer.df.iloc[:,1]))\n",
    "                yMax = max(yMax, max(layer.df.iloc[:,1]))\n",
    "            # adjust the map bound according the upper and lower bound of the dataset\n",
    "            self.map.fit_bounds([[xMin, yMin], [xMax, yMax]])\n",
    "        # if the input string does not match any of the options\n",
    "        else:\n",
    "            print(f\"ERROR: wrong string input: {string}\\n, valid inputs are: {self.layerNames} or 'all' or 'town\")\n",
    "\n",
    "# Nicolas\n",
    "def determine_extension(filename: str) -> str:\n",
    "    \"\"\"\n",
    "    Returns type of extension constant  associated with a Filename.\n",
    "    If Extension is not supperted IOError is raised.\n",
    "    \"\"\"\n",
    "    name_pattern = r'.*'\n",
    "    excel_reg = re.compile(name_pattern + r'.(xls|xlsx|xlsm|xlsb|xls)$')\n",
    "    csv_reg = re.compile(name_pattern + r'.csv$')\n",
    "    extension = None\n",
    "        \n",
    "    if excel_reg.match(filename):\n",
    "        extension = EXCEL_EXTENSION\n",
    "    elif csv_reg.match(filename):\n",
    "        extension = CSV_EXTENSION\n",
    "    else:\n",
    "        error_msg = \"File extension or name of \" + filename\n",
    "        error_msg += \" not supported. Use csv or excel documents\"\n",
    "        raise IOError(error_msg)\n",
    "    \n",
    "    return extension\n",
    "\n",
    "# Nicolas\n",
    "def get_dataframe(filename: str) -> pd.DataFrame:\n",
    "    \"\"\"\n",
    "    Returns a dataframe from an excel or csv file\n",
    "    \"\"\"\n",
    "    \n",
    "    extension = determine_extension(filename)\n",
    "    df = None\n",
    "    if extension == EXCEL_EXTENSION:\n",
    "        df = pd.read_excel(filename)\n",
    "    elif extension == CSV_EXTENSION:\n",
    "        df = pd.read_csv(filename)\n",
    "    else:\n",
    "        error_msg = \"File extension or name of \" + filename\n",
    "        error_msg += \" not supported. Use csv or excel documents\"\n",
    "        raise IOError(error_msg)\n",
    "    # doing validation, modification, and dataframe making at the same time\n",
    "    # could be a terribly bad idea but a quick fix for now --Chen\n",
    "    for i in range(df.shape[0]):\n",
    "        for j in range(2):\n",
    "            string = df.iloc[i, j]\n",
    "            if type(string) == str and '°' in string:\n",
    "                df.iloc[i,j] = conv_coord(string)\n",
    "    return df\n",
    "\n",
    "# Toby\n",
    "def conv_coord(deg_notation):\n",
    "    degrees, rest = deg_notation.split('°', 1)\n",
    "    minutes, rest = rest.split(\"'\", 1)\n",
    "    seconds, direction = rest.split('\"', 1)\n",
    "    dec_notation = float(degrees) + float(minutes)/60 + float(seconds)/3600\n",
    "    \n",
    "    if direction == 'S' or direction == 'W':\n",
    "        dec_notation = -dec_notation\n",
    "\n",
    "    return dec_notation\n",
    "\n",
    "# Nicolas\n",
    "def get_map(files: list) -> EWBMap:\n",
    "    \"\"\"\"\n",
    "    Returns a map object read from a csv or excel file\n",
    "    \"\"\"\n",
    "    map_object = EWBMap()\n",
    "    for f in files:\n",
    "        layer = get_layer(f)\n",
    "        map_object.layers.append(layer)\n",
    "        map_object.layerNames.append(layer.name)\n",
    "    map_object.makeMapfromLayers()\n",
    "    map_object.recenter()\n",
    "    return map_object\n",
    "\n",
    "# Chen\n",
    "def get_layer(filename: str) -> EWBLayer:\n",
    "    map_df = get_dataframe(filename)\n",
    "    layername, color, _= re.split(',|_|-|\\\\.',filename.replace(' ', ''))\n",
    "    layer_object = EWBLayer(layername, color, map_df)\n",
    "\n",
    "    for row in map_df.itertuples():\n",
    "        tmpRow = list(row)\n",
    "        make_popups(layer_object.featureGroup, tmpRow[1], tmpRow[2], tmpRow[3], \n",
    "                    tmpRow[4], tmpRow[5], tmpRow[6], layer_object.color)\n",
    "\n",
    "    return layer_object\n",
    "   \n",
    "# Toby\n",
    "def make_popups(layer, lat, lon, title, date=\"\", description=\"\", icon=\"home\", color=\"lightgray\"):\n",
    "    if date == \"\":\n",
    "        date = datetime.datetime.now()\n",
    "    folium.Marker(\n",
    "        location = [lat, lon],\n",
    "        icon = folium.Icon(icon=icon, color=color, prefix='fa'),\n",
    "        tooltip = title,\n",
    "        popup = folium.Popup(\n",
    "                    folium.Html('<b>%s</b> <br> <i>%s</i> <br> %s' %(title, date, description), script=True),\n",
    "                    # min_width=100,=> this is no longer valid\n",
    "                    max_width=450)\n",
    "        ).add_to(layer)\n",
    "    \n",
    "    \n",
    "# Danny (--> there is another data validation function not uploaded to this notebook to test too)\n",
    "def map_to_html (m, map_name, file_path =\"\"):\n",
    "    if file_path != \"\" and file_path[-1]!= '/':\n",
    "        file_path = file_path+\"/\"\n",
    "    path = file_path+map_name+\".html\"\n",
    "    m.save(path)\n",
    "    return path\n",
    "\n",
    "# still not working :/\n",
    "# we will not continue developing this function, I only keep this here for record keeping. --Chen\n",
    "def map_to_png(m, map_name, file_path =\"\", browser= 'Chrome'):\n",
    "    if file_path != \"\" and file_path[-1]!= '/':\n",
    "        file_path = file_path+\"/\"\n",
    "    fn = map_name+\".html\"\n",
    "    m.save(fn)\n",
    "    tmpurl='file://{path}/{mapfile}'.format(path=os.getcwd(),mapfile=fn)\n",
    "    delay =5\n",
    "    if browser == 'Safari':\n",
    "        browser = webdriver.Safari()\n",
    "    elif browser == 'Firefox':\n",
    "        browser = webdriver.Firefox()\n",
    "    else:\n",
    "        browser = webdriver.Chrome()\n",
    "    options = webdriver.ChromeOptions()\n",
    "    options.binary_location = \"./chromedriver.exe\"    #chrome binary location specified here\n",
    "    options.add_argument(\"--start-maximized\") #open Browser in maximized mode\n",
    "    options.add_argument(\"--no-sandbox\") #bypass OS security model\n",
    "    options.add_argument(\"--disable-dev-shm-usage\") #overcome limited resource problems\n",
    "    options.add_experimental_option(\"excludeSwitches\", [\"enable-automation\"])\n",
    "    options.add_experimental_option('useAutomationExtension', False)\n",
    "    brower = webdriver.Chrome(options=options, executable_path=r'./chromedriver.exe')\n",
    "    # browser.get('http://google.com/')\n",
    "    \n",
    "    browser.get(tmpurl)\n",
    "    # time.sleep(delay)\n",
    "    # browser.save_screenshot(file_path+map_name+'.png')\n",
    "    # browser.quit()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "L3-hY7M6DCfm"
   },
   "source": [
    "# user code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 124
    },
    "colab_type": "code",
    "id": "jeapY2z262Wj",
    "outputId": "a7abcc27-52b6-4eda-ec41-101f2771a73b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly&response_type=code\n",
      "\n",
      "Enter your authorization code:\n",
      "··········\n",
      "Mounted at /content/drive\n"
     ]
    }
   ],
   "source": [
    "# run this cell if notebook is executed in Google Colab\n",
    "# ignore if run in jupyter notebook\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 87
    },
    "colab_type": "code",
    "id": "dkUuyeBG6pJ0",
    "outputId": "d4b26426-410c-4671-b1b6-e3556e050492"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/content/drive/My Drive/Colab Notebooks/folium\n",
      "app_update.ipynb  sample_blue.xlsx  Surveyees_orange.xlsx    vertical_red.xlsx\n",
      "chromedriver.exe  sampleHTML.html   Surveyees,Yellow.csv\n",
      "folium.ipynb\t  samplePNG.html    Surveyees,Yellow.gsheet\n"
     ]
    }
   ],
   "source": [
    "# change the directory to where you store the notebook and the excel/csv file\n",
    "%cd /content/drive/My Drive/Colab Notebooks/folium\n",
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "OwUHcP0h6pJ4",
    "outputId": "32a1eb63-e7c9-4577-f20d-5e886908b9f0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./sampleHTML.html'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# test cases\n",
    "# construction block\n",
    "sampleMap = get_map(['Surveyees_orange.xlsx'])\n",
    "map_to_html(sampleMap.map, 'sampleHTML', '.')\n",
    "# sampleMap.map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 707
    },
    "colab_type": "code",
    "id": "T8cu6k5eetIq",
    "outputId": "d9706ffd-a2ba-43e7-dc51-4a015d918d9b"
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div style=\"width:100%;\"><div style=\"position:relative;width:100%;height:0;padding-bottom:60%;\"><span style=\"color:#565656\">Make this Notebook Trusted to load map: File -> Trust Notebook</span><iframe src=\"about:blank\" style=\"position:absolute;width:100%;height:100%;left:0;top:0;border:none !important;\" data-html=<!DOCTYPE html>
<head>    
    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
    
        <script>
            L_NO_TOUCH = false;
            L_DISABLE_3D = false;
        </script>
    
    <script src="https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.js"></script>
    <script src="https://code.jquery.com/jquery-1.12.4.min.js"></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/js/bootstrap.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.js"></script>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/leaflet@1.6.0/dist/leaflet.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.2.0/css/bootstrap-theme.min.css"/>
    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css"/>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/Leaflet.awesome-markers/2.0.2/leaflet.awesome-markers.css"/>
    <link rel="stylesheet" href="https://rawcdn.githack.com/python-visualization/folium/master/folium/templates/leaflet.awesome.rotate.css"/>
    <style>html, body {width: 100%;height: 100%;margin: 0;padding: 0;}</style>
    <style>#map {position:absolute;top:0;bottom:0;right:0;left:0;}</style>
    
            <meta name="viewport" content="width=device-width,
                initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
            <style>
                #map_b8763a66ac32447b91343e92bd1806e5 {
                    position: relative;
                    width: 100.0%;
                    height: 100.0%;
                    left: 0.0%;
                    top: 0.0%;
                }
            </style>
        
</head>
<body>    
    
            <div class="folium-map" id="map_b8763a66ac32447b91343e92bd1806e5" ></div>
        
</body>
<script>    
    
            var map_b8763a66ac32447b91343e92bd1806e5 = L.map(
                "map_b8763a66ac32447b91343e92bd1806e5",
                {
                    center: [45.372, -121.6972],
                    crs: L.CRS.EPSG3857,
                    zoom: 12,
                    zoomControl: true,
                    preferCanvas: false,
                }
            );

            

        
    
            var tile_layer_47aa134fe8ae4442a93ce1f4b61e7efe = L.tileLayer(
                "https://stamen-tiles-{s}.a.ssl.fastly.net/terrain/{z}/{x}/{y}.jpg",
                {"attribution": "Map tiles by \u003ca href=\"http://stamen.com\"\u003eStamen Design\u003c/a\u003e, under \u003ca href=\"http://creativecommons.org/licenses/by/3.0\"\u003eCC BY 3.0\u003c/a\u003e. Data by \u0026copy; \u003ca href=\"http://openstreetmap.org\"\u003eOpenStreetMap\u003c/a\u003e, under \u003ca href=\"http://creativecommons.org/licenses/by-sa/3.0\"\u003eCC BY SA\u003c/a\u003e.", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_b8763a66ac32447b91343e92bd1806e5);
        
    
            var tile_layer_2b377b612339426f96e2ca568cf64e1a = L.tileLayer(
                "https://stamen-tiles-{s}.a.ssl.fastly.net/toner/{z}/{x}/{y}.png",
                {"attribution": "Map tiles by \u003ca href=\"http://stamen.com\"\u003eStamen Design\u003c/a\u003e, under \u003ca href=\"http://creativecommons.org/licenses/by/3.0\"\u003eCC BY 3.0\u003c/a\u003e. Data by \u0026copy; \u003ca href=\"http://openstreetmap.org\"\u003eOpenStreetMap\u003c/a\u003e, under \u003ca href=\"http://www.openstreetmap.org/copyright\"\u003eODbL\u003c/a\u003e.", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_b8763a66ac32447b91343e92bd1806e5);
        
    
            var tile_layer_3682683c8a3c435ca88f868a53d59d43 = L.tileLayer(
                "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
                {"attribution": "Data by \u0026copy; \u003ca href=\"http://openstreetmap.org\"\u003eOpenStreetMap\u003c/a\u003e, under \u003ca href=\"http://www.openstreetmap.org/copyright\"\u003eODbL\u003c/a\u003e.", "detectRetina": false, "maxNativeZoom": 18, "maxZoom": 18, "minZoom": 0, "noWrap": false, "opacity": 1, "subdomains": "abc", "tms": false}
            ).addTo(map_b8763a66ac32447b91343e92bd1806e5);
        
    
            var feature_group_91f352cc3e464747b15bb23a0fb41502 = L.featureGroup(
                {}
            ).addTo(map_b8763a66ac32447b91343e92bd1806e5);
        
    
            var marker_640cbeb3a94a4625bf79ad101662a134 = L.marker(
                [5.82168611111111, -0.245852777777777],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_25c14a3fa47b44b19b83f842bcf64061 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_640cbeb3a94a4625bf79ad101662a134.setIcon(icon_25c14a3fa47b44b19b83f842bcf64061);
        
    
        var popup_694be0bfe34740b99a140f3a23574bff = L.popup({"maxWidth": 450});

        
            var html_eea58e55d261452b9be9d2663174239b = $(`<div id="html_eea58e55d261452b9be9d2663174239b" style="width: 100.0%; height: 100.0%;"><b>Vincent</b> <br> <i>2020-08-10 00:00:00</i> <br> North</div>`)[0];
            popup_694be0bfe34740b99a140f3a23574bff.setContent(html_eea58e55d261452b9be9d2663174239b);
        

        marker_640cbeb3a94a4625bf79ad101662a134.bindPopup(popup_694be0bfe34740b99a140f3a23574bff)
        ;

        
    
    
            marker_640cbeb3a94a4625bf79ad101662a134.bindTooltip(
                `<div>
                     Vincent
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_1839274467984506868faef7ab98e162 = L.marker(
                [5.82357222222222, -0.247627777777777],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_28f7729d347145bb87bfd790c51e03ea = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_1839274467984506868faef7ab98e162.setIcon(icon_28f7729d347145bb87bfd790c51e03ea);
        
    
        var popup_1c8b1dd2fc6f4b529e4007f30f3f103f = L.popup({"maxWidth": 450});

        
            var html_0710975da3fd4b908e33723986a32f20 = $(`<div id="html_0710975da3fd4b908e33723986a32f20" style="width: 100.0%; height: 100.0%;"><b>Agnes</b> <br> <i>2020-08-10 00:00:00</i> <br> North</div>`)[0];
            popup_1c8b1dd2fc6f4b529e4007f30f3f103f.setContent(html_0710975da3fd4b908e33723986a32f20);
        

        marker_1839274467984506868faef7ab98e162.bindPopup(popup_1c8b1dd2fc6f4b529e4007f30f3f103f)
        ;

        
    
    
            marker_1839274467984506868faef7ab98e162.bindTooltip(
                `<div>
                     Agnes
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_5f4b44486c314356b79c79db810dc4cb = L.marker(
                [5.82276666666666, -0.245494444444444],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_77cfaf0fe5b74633a4ed192ec22affd2 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_5f4b44486c314356b79c79db810dc4cb.setIcon(icon_77cfaf0fe5b74633a4ed192ec22affd2);
        
    
        var popup_ea77a92fb02e43e89ce7603aa40ca164 = L.popup({"maxWidth": 450});

        
            var html_d2b2007290bf4cfb8be8134f67cc1afd = $(`<div id="html_d2b2007290bf4cfb8be8134f67cc1afd" style="width: 100.0%; height: 100.0%;"><b>Faustina</b> <br> <i>2020-08-10 00:00:00</i> <br> North</div>`)[0];
            popup_ea77a92fb02e43e89ce7603aa40ca164.setContent(html_d2b2007290bf4cfb8be8134f67cc1afd);
        

        marker_5f4b44486c314356b79c79db810dc4cb.bindPopup(popup_ea77a92fb02e43e89ce7603aa40ca164)
        ;

        
    
    
            marker_5f4b44486c314356b79c79db810dc4cb.bindTooltip(
                `<div>
                     Faustina
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_cb559f904c7b48f792ffc8cddf607ea4 = L.marker(
                [5.82234166666666, -0.246161111111111],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_34c1b25f3b2941c0a66db773699798ac = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_cb559f904c7b48f792ffc8cddf607ea4.setIcon(icon_34c1b25f3b2941c0a66db773699798ac);
        
    
        var popup_07e99ab242bf4d9c8caa16606868f160 = L.popup({"maxWidth": 450});

        
            var html_dc270ac8a76e44e9b841320071f1470a = $(`<div id="html_dc270ac8a76e44e9b841320071f1470a" style="width: 100.0%; height: 100.0%;"><b>Memunato</b> <br> <i>2020-08-10 00:00:00</i> <br> North</div>`)[0];
            popup_07e99ab242bf4d9c8caa16606868f160.setContent(html_dc270ac8a76e44e9b841320071f1470a);
        

        marker_cb559f904c7b48f792ffc8cddf607ea4.bindPopup(popup_07e99ab242bf4d9c8caa16606868f160)
        ;

        
    
    
            marker_cb559f904c7b48f792ffc8cddf607ea4.bindTooltip(
                `<div>
                     Memunato
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_76a1ea49ec1143958bb4e0a2465b76fc = L.marker(
                [5.82201388888888, -0.246202777777777],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_fc388ab9ce874564b1a771d1ab7955cc = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_76a1ea49ec1143958bb4e0a2465b76fc.setIcon(icon_fc388ab9ce874564b1a771d1ab7955cc);
        
    
        var popup_c6c2c74c00c445d3a46d79a1e4b613ba = L.popup({"maxWidth": 450});

        
            var html_a717a91e804c41d8a771f48557164a73 = $(`<div id="html_a717a91e804c41d8a771f48557164a73" style="width: 100.0%; height: 100.0%;"><b>Joseph</b> <br> <i>2020-08-11 00:00:00</i> <br> North</div>`)[0];
            popup_c6c2c74c00c445d3a46d79a1e4b613ba.setContent(html_a717a91e804c41d8a771f48557164a73);
        

        marker_76a1ea49ec1143958bb4e0a2465b76fc.bindPopup(popup_c6c2c74c00c445d3a46d79a1e4b613ba)
        ;

        
    
    
            marker_76a1ea49ec1143958bb4e0a2465b76fc.bindTooltip(
                `<div>
                     Joseph
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_84dcb5e46d944057baba25e12a2e2512 = L.marker(
                [5.82171388888888, -0.245702777777777],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_69080b4d6ebf47aba9515a78db19b8df = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_84dcb5e46d944057baba25e12a2e2512.setIcon(icon_69080b4d6ebf47aba9515a78db19b8df);
        
    
        var popup_fe5dc3ffa9a94fccbea603c2d7b5ff96 = L.popup({"maxWidth": 450});

        
            var html_a1e4cfc1f79e4ae2b8f93712c3d6c884 = $(`<div id="html_a1e4cfc1f79e4ae2b8f93712c3d6c884" style="width: 100.0%; height: 100.0%;"><b>Beatrice</b> <br> <i>2020-08-11 00:00:00</i> <br> North</div>`)[0];
            popup_fe5dc3ffa9a94fccbea603c2d7b5ff96.setContent(html_a1e4cfc1f79e4ae2b8f93712c3d6c884);
        

        marker_84dcb5e46d944057baba25e12a2e2512.bindPopup(popup_fe5dc3ffa9a94fccbea603c2d7b5ff96)
        ;

        
    
    
            marker_84dcb5e46d944057baba25e12a2e2512.bindTooltip(
                `<div>
                     Beatrice
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_9456b0f9d5ae47698162a670be8db311 = L.marker(
                [5.82286111111111, -0.244991666666666],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_31dedaf8cbe644fd9606a8b4d13f2bb1 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_9456b0f9d5ae47698162a670be8db311.setIcon(icon_31dedaf8cbe644fd9606a8b4d13f2bb1);
        
    
        var popup_966f55a0a9e44643802937b80bf69734 = L.popup({"maxWidth": 450});

        
            var html_12126e4c37f84431b402e172c0efd7de = $(`<div id="html_12126e4c37f84431b402e172c0efd7de" style="width: 100.0%; height: 100.0%;"><b>Olivia</b> <br> <i>2020-08-11 00:00:00</i> <br> North</div>`)[0];
            popup_966f55a0a9e44643802937b80bf69734.setContent(html_12126e4c37f84431b402e172c0efd7de);
        

        marker_9456b0f9d5ae47698162a670be8db311.bindPopup(popup_966f55a0a9e44643802937b80bf69734)
        ;

        
    
    
            marker_9456b0f9d5ae47698162a670be8db311.bindTooltip(
                `<div>
                     Olivia
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_70e726f49c2e4917aac92c092c04fb27 = L.marker(
                [5.82201388888888, -0.246202777777777],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_498e067bf441473d9e8f4f69f4639c3d = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_70e726f49c2e4917aac92c092c04fb27.setIcon(icon_498e067bf441473d9e8f4f69f4639c3d);
        
    
        var popup_4ed4bd25f3624f6ca094c8d98221ff99 = L.popup({"maxWidth": 450});

        
            var html_3427fce5fbe144968f889c2395506ba2 = $(`<div id="html_3427fce5fbe144968f889c2395506ba2" style="width: 100.0%; height: 100.0%;"><b>Mavis</b> <br> <i>2020-08-11 00:00:00</i> <br> North</div>`)[0];
            popup_4ed4bd25f3624f6ca094c8d98221ff99.setContent(html_3427fce5fbe144968f889c2395506ba2);
        

        marker_70e726f49c2e4917aac92c092c04fb27.bindPopup(popup_4ed4bd25f3624f6ca094c8d98221ff99)
        ;

        
    
    
            marker_70e726f49c2e4917aac92c092c04fb27.bindTooltip(
                `<div>
                     Mavis
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_b391c7afc4424264a23781bef86f06c6 = L.marker(
                [5.82281111111111, -0.244730555555555],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_f72c02c5bae44d5ba699fca7e1d792f4 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_b391c7afc4424264a23781bef86f06c6.setIcon(icon_f72c02c5bae44d5ba699fca7e1d792f4);
        
    
        var popup_a0f687fa6efa4ed7aa56402c1a9bb23b = L.popup({"maxWidth": 450});

        
            var html_290470d876d4445ba2a0839056105d0b = $(`<div id="html_290470d876d4445ba2a0839056105d0b" style="width: 100.0%; height: 100.0%;"><b>Regina</b> <br> <i>2020-08-11 00:00:00</i> <br> South</div>`)[0];
            popup_a0f687fa6efa4ed7aa56402c1a9bb23b.setContent(html_290470d876d4445ba2a0839056105d0b);
        

        marker_b391c7afc4424264a23781bef86f06c6.bindPopup(popup_a0f687fa6efa4ed7aa56402c1a9bb23b)
        ;

        
    
    
            marker_b391c7afc4424264a23781bef86f06c6.bindTooltip(
                `<div>
                     Regina
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_dcd54f0d2527488888d927f70c3a9bac = L.marker(
                [5.82203611111111, -0.245333333333333],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_cb8f624b5d6d4c3fb5a294d4a50d7612 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_dcd54f0d2527488888d927f70c3a9bac.setIcon(icon_cb8f624b5d6d4c3fb5a294d4a50d7612);
        
    
        var popup_f445c5e9887a406396cb13d65664ee60 = L.popup({"maxWidth": 450});

        
            var html_0dc322fa6d3e41c39c1290532e291f40 = $(`<div id="html_0dc322fa6d3e41c39c1290532e291f40" style="width: 100.0%; height: 100.0%;"><b>Abena</b> <br> <i>2020-08-11 00:00:00</i> <br> South</div>`)[0];
            popup_f445c5e9887a406396cb13d65664ee60.setContent(html_0dc322fa6d3e41c39c1290532e291f40);
        

        marker_dcd54f0d2527488888d927f70c3a9bac.bindPopup(popup_f445c5e9887a406396cb13d65664ee60)
        ;

        
    
    
            marker_dcd54f0d2527488888d927f70c3a9bac.bindTooltip(
                `<div>
                     Abena
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_9c711de7b3e64515a71c15b5e377db97 = L.marker(
                [5.82242777777777, -0.245463888888888],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_a8af5cb9af334a58b15c6e7841e31fde = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_9c711de7b3e64515a71c15b5e377db97.setIcon(icon_a8af5cb9af334a58b15c6e7841e31fde);
        
    
        var popup_7574592e0d174703af4f8ddd5bb8b80c = L.popup({"maxWidth": 450});

        
            var html_20d4993bd9ca4affbb96b3c16cd83317 = $(`<div id="html_20d4993bd9ca4affbb96b3c16cd83317" style="width: 100.0%; height: 100.0%;"><b>Adobea</b> <br> <i>2020-08-11 00:00:00</i> <br> South</div>`)[0];
            popup_7574592e0d174703af4f8ddd5bb8b80c.setContent(html_20d4993bd9ca4affbb96b3c16cd83317);
        

        marker_9c711de7b3e64515a71c15b5e377db97.bindPopup(popup_7574592e0d174703af4f8ddd5bb8b80c)
        ;

        
    
    
            marker_9c711de7b3e64515a71c15b5e377db97.bindTooltip(
                `<div>
                     Adobea
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_7752a7030d2d4e238a0ab336dce4ce55 = L.marker(
                [5.82288888888888, -0.245627777777777],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_95228275235745c1b49a3c10b040ee58 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_7752a7030d2d4e238a0ab336dce4ce55.setIcon(icon_95228275235745c1b49a3c10b040ee58);
        
    
        var popup_827bbb9f97804a54bb588a49c3040af6 = L.popup({"maxWidth": 450});

        
            var html_c64c7ed219a549398b2e930de3eb2548 = $(`<div id="html_c64c7ed219a549398b2e930de3eb2548" style="width: 100.0%; height: 100.0%;"><b>Yaaofusa</b> <br> <i>2020-08-12 00:00:00</i> <br> South</div>`)[0];
            popup_827bbb9f97804a54bb588a49c3040af6.setContent(html_c64c7ed219a549398b2e930de3eb2548);
        

        marker_7752a7030d2d4e238a0ab336dce4ce55.bindPopup(popup_827bbb9f97804a54bb588a49c3040af6)
        ;

        
    
    
            marker_7752a7030d2d4e238a0ab336dce4ce55.bindTooltip(
                `<div>
                     Yaaofusa
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_4298b52dde284bf08527cee5f89511b6 = L.marker(
                [5.82268333333333, -0.245316666666666],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_d2896f742b6d4ef08f40e5302e22ea99 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_4298b52dde284bf08527cee5f89511b6.setIcon(icon_d2896f742b6d4ef08f40e5302e22ea99);
        
    
        var popup_d2215d512ffa436f98d622d343be8027 = L.popup({"maxWidth": 450});

        
            var html_5ce95ee2f71e49349309800ea314f5be = $(`<div id="html_5ce95ee2f71e49349309800ea314f5be" style="width: 100.0%; height: 100.0%;"><b>Christiana</b> <br> <i>2020-08-12 00:00:00</i> <br> South</div>`)[0];
            popup_d2215d512ffa436f98d622d343be8027.setContent(html_5ce95ee2f71e49349309800ea314f5be);
        

        marker_4298b52dde284bf08527cee5f89511b6.bindPopup(popup_d2215d512ffa436f98d622d343be8027)
        ;

        
    
    
            marker_4298b52dde284bf08527cee5f89511b6.bindTooltip(
                `<div>
                     Christiana
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_be15bef5316445f4bd124f37a9195730 = L.marker(
                [5.82211111111111, -0.249105555555555],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_18b75bb727c14c2093babe0719ec88d2 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_be15bef5316445f4bd124f37a9195730.setIcon(icon_18b75bb727c14c2093babe0719ec88d2);
        
    
        var popup_67bc85de8e1f40d6928a14d0f5f813e6 = L.popup({"maxWidth": 450});

        
            var html_f623a3af510d44a8bb11637c6922fd02 = $(`<div id="html_f623a3af510d44a8bb11637c6922fd02" style="width: 100.0%; height: 100.0%;"><b>Mawutor</b> <br> <i>2020-08-12 00:00:00</i> <br> South</div>`)[0];
            popup_67bc85de8e1f40d6928a14d0f5f813e6.setContent(html_f623a3af510d44a8bb11637c6922fd02);
        

        marker_be15bef5316445f4bd124f37a9195730.bindPopup(popup_67bc85de8e1f40d6928a14d0f5f813e6)
        ;

        
    
    
            marker_be15bef5316445f4bd124f37a9195730.bindTooltip(
                `<div>
                     Mawutor
                 </div>`,
                {"sticky": true}
            );
        
    
            var marker_864502970a7a4581b5b873ad09ee4af1 = L.marker(
                [5.82211111111111, -0.249105555555555],
                {}
            ).addTo(feature_group_91f352cc3e464747b15bb23a0fb41502);
        
    
            var icon_37a11c4847a4486ca687a22b0dad8c19 = L.AwesomeMarkers.icon(
                {"extraClasses": "fa-rotate-0", "icon": "home", "iconColor": "white", "markerColor": "orange", "prefix": "fa"}
            );
            marker_864502970a7a4581b5b873ad09ee4af1.setIcon(icon_37a11c4847a4486ca687a22b0dad8c19);
        
    
        var popup_6f300457d52e4b9b9fc0a28d462ad9a3 = L.popup({"maxWidth": 450});

        
            var html_e52cb4ba0b11441b89771888e8a037dd = $(`<div id="html_e52cb4ba0b11441b89771888e8a037dd" style="width: 100.0%; height: 100.0%;"><b>Mawutor</b> <br> <i>2020-08-12 00:00:00</i> <br> South</div>`)[0];
            popup_6f300457d52e4b9b9fc0a28d462ad9a3.setContent(html_e52cb4ba0b11441b89771888e8a037dd);
        

        marker_864502970a7a4581b5b873ad09ee4af1.bindPopup(popup_6f300457d52e4b9b9fc0a28d462ad9a3)
        ;

        
    
    
            marker_864502970a7a4581b5b873ad09ee4af1.bindTooltip(
                `<div>
                     Mawutor
                 </div>`,
                {"sticky": true}
            );
        
    
            var layer_control_3c2bc87fe1bd4f64adc6de24bc57665c = {
                base_layers : {
                    "stamenterrain" : tile_layer_47aa134fe8ae4442a93ce1f4b61e7efe,
                    "stamentoner" : tile_layer_2b377b612339426f96e2ca568cf64e1a,
                    "openstreetmap" : tile_layer_3682683c8a3c435ca88f868a53d59d43,
                },
                overlays :  {
                    "Surveyees" : feature_group_91f352cc3e464747b15bb23a0fb41502,
                },
            };
            L.control.layers(
                layer_control_3c2bc87fe1bd4f64adc6de24bc57665c.base_layers,
                layer_control_3c2bc87fe1bd4f64adc6de24bc57665c.overlays,
                {"autoZIndex": true, "collapsed": true, "position": "topright"}
            ).addTo(map_b8763a66ac32447b91343e92bd1806e5);
            tile_layer_2b377b612339426f96e2ca568cf64e1a.remove();
            tile_layer_3682683c8a3c435ca88f868a53d59d43.remove();
            tile_layer_47aa134fe8ae4442a93ce1f4b61e7efe.remove();
        
    
            map_b8763a66ac32447b91343e92bd1806e5.fitBounds(
                [[5.82168611111111, -0.249105555555555], [5.82357222222222, -0.244730555555555]],
                {}
            );
        
    
            map_b8763a66ac32447b91343e92bd1806e5.fitBounds(
                [[5.82168611111111, -0.249105555555555], [5.82357222222222, -0.244730555555555]],
                {}
            );
        
</script> onload=\"this.contentDocument.open();this.contentDocument.write(atob(this.getAttribute('data-html')));this.contentDocument.close();\" allowfullscreen webkitallowfullscreen mozallowfullscreen></iframe></div></div>"
      ],
      "text/plain": [
       "<folium.folium.Map at 0x1af8b072ec8>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# visualization block\n",
    "sampleMap.recenter()\n",
    "sampleMap.map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "app_update_0825.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}