2017-09-09-hurricane_irma.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploring the NHC Advisories and Sea Surface Height during Hurricane Irma\n",
    "\n",
    "\n",
    "This notebook aims to demonstrate how to create a simple interactive GIS map with the National Hurricane Center predictions [1] and the observed sea surface height from CO-OPS [2].\n",
    "\n",
    "\n",
    "See https://tidesandcurrents.noaa.gov/quicklook/view.html?name=IRMA for the latest information on Irma.\n",
    "\n",
    "1. http://www.nhc.noaa.gov/gis/\n",
    "2. https://opendap.co-ops.nos.noaa.gov/ioos-dif-sos/\n",
    "\n",
    "\n",
    "First we have to download the National Hurricane Center (NHC) GIS 5 day predictions data for Irma.\n",
    "\n",
    "NHC codes storms are coded with 8 letter names:\n",
    "- 2 char for region `al` &rarr; Atlantic\n",
    "- 2 char for number `11` is Irma\n",
    "- and 4 char for year, `2017`\n",
    "\n",
    "Browse http://www.nhc.noaa.gov/gis/archive_wsurge.php?year=2017 to find other hurricanes code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "code = 'al112017'\n",
    "# code = 'al032018'\n",
    "hurricane = '{}_5day'.format(code)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "import sys\n",
    "try:\n",
    "    from urllib.request import urlopen, urlretrieve\n",
    "except Exception:\n",
    "    from urllib import urlopen, urlretrieve\n",
    "import lxml.html\n",
    "\n",
    "\n",
    "def url_lister(url):\n",
    "    urls = []\n",
    "    connection = urlopen(url)\n",
    "    dom = lxml.html.fromstring(connection.read())\n",
    "    for link in dom.xpath('//a/@href'):\n",
    "        urls.append(link)\n",
    "    return urls\n",
    "\n",
    "\n",
    "def download(url, path):\n",
    "    sys.stdout.write(fname + '\\n')\n",
    "    if not os.path.isfile(path):\n",
    "        urlretrieve(\n",
    "            url,\n",
    "            filename=path,\n",
    "            reporthook=progress_hook(sys.stdout)\n",
    "        )\n",
    "        sys.stdout.write('\\n')\n",
    "        sys.stdout.flush()\n",
    "\n",
    "\n",
    "def progress_hook(out):\n",
    "    \"\"\"\n",
    "    Return a progress hook function, suitable for passing to\n",
    "    urllib.retrieve, that writes to the file object *out*.\n",
    "    \"\"\"\n",
    "\n",
    "    def it(n, bs, ts):\n",
    "        got = n * bs\n",
    "        if ts < 0:\n",
    "            outof = ''\n",
    "        else:\n",
    "            # On the last block n*bs can exceed ts, so we clamp it\n",
    "            # to avoid awkward questions.\n",
    "            got = min(got, ts)\n",
    "            outof = '/%d [%d%%]' % (ts, 100 * got // ts)\n",
    "        out.write(\"\\r  %d%s\" % (got, outof))\n",
    "        out.flush()\n",
    "    return it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nhc = 'http://www.nhc.noaa.gov/gis/forecast/archive/'\n",
    "\n",
    "# We don't need the latest file b/c that is redundant to the latest number.\n",
    "fnames = [\n",
    "    fname for fname in url_lister(nhc)\n",
    "    if fname.startswith(hurricane) and 'latest' not in fname\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "base = os.path.abspath(\n",
    "    os.path.join(os.path.curdir, 'data', hurricane)\n",
    ")\n",
    "\n",
    "if not os.path.exists(base):\n",
    "    os.makedirs(base)\n",
    "\n",
    "for fname in fnames:\n",
    "    url = '{}/{}'.format(nhc, fname)\n",
    "    path = os.path.join(base, fname)\n",
    "    download(url, path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cells below we use `geopandas` to load the data we just downloaded. We will use only the prediction cone (`png`) and the track points (`pts`), but feel free to explore this data further, there is plenty more there."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "\n",
    "# Only needed to run on binder!\n",
    "# See https://gitter.im/binder-project/binder?at=59bc2498c101bc4e3acfc9f1\n",
    "os.environ['CPL_ZIP_ENCODING'] = 'UTF-8'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "import geopandas\n",
    "\n",
    "\n",
    "cones, points = [], []\n",
    "for fname in sorted(glob(os.path.join(base, '{}_*.zip'.format(hurricane)))):\n",
    "    number = os.path.splitext(os.path.split(fname)[-1])[0].split('_')[-1]\n",
    "    pgn = geopandas.read_file(\n",
    "        '/{}-{}_5day_pgn.shp'.format(code, number),\n",
    "        vfs='zip://{}'.format(fname)\n",
    "    )\n",
    "    cones.append(pgn)\n",
    "\n",
    "    pts = geopandas.read_file(\n",
    "        '/{}-{}_5day_pts.shp'.format(code, number),\n",
    "        vfs='zip://{}'.format(fname)\n",
    "    )\n",
    "    # Only the first \"obsevartion.\"\n",
    "    points.append(pts.iloc[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a color code for the point track."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = {\n",
    "    'Subtropical Depression': 'yellow',\n",
    "    'Tropical Depression': 'yellow',\n",
    "    'Tropical Storm': 'orange',\n",
    "    'Subtropical Storm': 'orange',\n",
    "    'Hurricane': 'red',\n",
    "    'Major Hurricane': 'crimson'\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can get all the information we need from those GIS files. Let's start with the event dates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import arrow\n",
    "\n",
    "# We are ignoring the timezone, like AST (Atlantic Time Standar) b/c\n",
    "# those are not a unique identifiers and we cannot disambiguate.\n",
    "start = points[0]['FLDATELBL']\n",
    "end = points[-1]['FLDATELBL']\n",
    "\n",
    "start = arrow.get(start, 'YYYY-MM-DD h:mm A ddd').naive\n",
    "end = arrow.get(end, 'YYYY-MM-DD h:mm A ddd').naive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And the bounding box to search the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from shapely.geometry import LineString\n",
    "from shapely.ops import cascaded_union\n",
    "\n",
    "last_cone = cones[-1]['geometry'].iloc[0]\n",
    "track = LineString([point['geometry'] for point in points])\n",
    "\n",
    "polygon = cascaded_union([last_cone, track])\n",
    "\n",
    "# Add a buffer to find the stations along the track.\n",
    "bbox = polygon.buffer(2).bounds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the bounding box is derived from the track and the latest prediction cone."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "strbbox = ', '.join(format(v, '.2f') for v in bbox)\n",
    "print('bbox: {}\\nstart: {}\\n  end: {}'.format(strbbox, start, end))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to build a filter with those parameters to find the observations along the Hurricane path. We still need to specify:\n",
    "\n",
    "- the units for the observations;\n",
    "- and the SOS name for the variables of interest.\n",
    "\n",
    "Next, we can use `pyoos` to assemble a collector to download the data into a pandas `DataFrame`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cf_units\n",
    "from ioos_tools.ioos import collector2table\n",
    "import pandas as pd\n",
    "from pyoos.collectors.coops.coops_sos import CoopsSos\n",
    "from retrying import retry\n",
    "\n",
    "\n",
    "# We need to retry in case of failure b/c the server cannot handle\n",
    "# the high traffic during events like Irma.\n",
    "@retry(stop_max_attempt_number=5, wait_fixed=3000)\n",
    "def get_coops(start, end, sos_name, units, bbox, verbose=False):\n",
    "    collector = CoopsSos()\n",
    "    collector.set_bbox(bbox)\n",
    "    collector.end_time = end\n",
    "    collector.start_time = start\n",
    "    collector.variables = [sos_name]\n",
    "    ofrs = collector.server.offerings\n",
    "    title = collector.server.identification.title\n",
    "    config = dict(\n",
    "        units=units,\n",
    "        sos_name=sos_name,\n",
    "    )\n",
    "\n",
    "    data = collector2table(\n",
    "        collector=collector,\n",
    "        config=config,\n",
    "        col='{} ({})'.format(sos_name, units.format(cf_units.UT_ISO_8859_1))\n",
    "    )\n",
    "\n",
    "    # Clean the table.\n",
    "    table = dict(\n",
    "        station_name=[s._metadata.get('station_name') for s in data],\n",
    "        station_code=[s._metadata.get('station_code') for s in data],\n",
    "        sensor=[s._metadata.get('sensor') for s in data],\n",
    "        lon=[s._metadata.get('lon') for s in data],\n",
    "        lat=[s._metadata.get('lat') for s in data],\n",
    "        depth=[s._metadata.get('depth', 'NA') for s in data],\n",
    "    )\n",
    "\n",
    "    table = pd.DataFrame(table).set_index('station_name')\n",
    "    if verbose:\n",
    "        print('Collector offerings')\n",
    "        print('{}: {} offerings'.format(title, len(ofrs)))\n",
    "    return data, table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "ssh, ssh_table = get_coops(\n",
    "    start=start,\n",
    "    end=end,\n",
    "    sos_name='water_surface_height_above_reference_datum',\n",
    "    units=cf_units.Unit('meters'),\n",
    "    bbox=bbox,\n",
    ")\n",
    "\n",
    "ssh_table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "wind_speed, wind_speed_table = get_coops(\n",
    "    start=start,\n",
    "    end=end,\n",
    "    sos_name='wind_speed',\n",
    "    units=cf_units.Unit('m/s'),\n",
    "    bbox=bbox,\n",
    ")\n",
    "\n",
    "wind_speed_table"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For simplicity we will use only the stations that have both wind speed and sea surface height and reject those that have only one or the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "common = set(ssh_table['station_code']).intersection(wind_speed_table['station_code'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ssh_obs, win_obs = [], []\n",
    "for station in common:\n",
    "    ssh_obs.extend([obs for obs in ssh if obs._metadata['station_code'] == station])\n",
    "    win_obs.extend([obs for obs in wind_speed if obs._metadata['station_code'] == station])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "index = pd.date_range(\n",
    "    start=start.replace(tzinfo=None),\n",
    "    end=end.replace(tzinfo=None),\n",
    "    freq='15min'\n",
    ")\n",
    "\n",
    "# Re-index and rename series.\n",
    "ssh_observations = []\n",
    "for series in ssh_obs:\n",
    "    _metadata = series._metadata\n",
    "    obs = series.reindex(index=index, limit=1, method='nearest')\n",
    "    obs._metadata = _metadata\n",
    "    obs.name = _metadata['station_name']\n",
    "    ssh_observations.append(obs)\n",
    "\n",
    "winds_observations = []\n",
    "for series in win_obs:\n",
    "    _metadata = series._metadata\n",
    "    obs = series.reindex(index=index, limit=1, method='nearest')\n",
    "    obs._metadata = _metadata\n",
    "    obs.name = _metadata['station_name']\n",
    "    winds_observations.append(obs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a look at some stations to see if the data is OK. Below we have a station in Naples, FL along the Gulf of Mexico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "try:\n",
    "    station = '8725110'\n",
    "\n",
    "    w = [obs for obs in winds_observations if obs._metadata['station_code'] == station][0]\n",
    "    s = [obs for obs in ssh_observations if obs._metadata['station_code'] == station][0]\n",
    "\n",
    "    fig, ax = plt.subplots(figsize=(17, 3.75))\n",
    "    s['2017-9-10':].plot(ax=ax, label='Sea surface height (m)', color='#0000ff')\n",
    "    ax1 = w['2017-9-10':].plot(ax=ax, label='Wind speed (m/s)', color='#9900cc', secondary_y=True)\n",
    "    ax.set_title(w._metadata['station_name'])\n",
    "\n",
    "    lines = ax.get_lines() + ax.right_ax.get_lines()\n",
    "    ax.legend(lines, [l.get_label() for l in lines], loc='upper left')\n",
    "    ax.axhline(0, color='black')\n",
    "\n",
    "    ax.set_ylabel('Sea surface height (m)', color='#0000ff')\n",
    "    ax.right_ax.set_ylabel('Wind speed (m/s)', color='#9900cc')\n",
    "\n",
    "    ax1.annotate(\n",
    "        'Eye of the hurricane',\n",
    "        xy=(w['2017-9-10':].argmin().to_pydatetime(), w['2017-9-10':].min()),\n",
    "        xytext=(5, 10),\n",
    "        textcoords='offset points',\n",
    "        arrowprops=dict(\n",
    "            arrowstyle='simple',\n",
    "            facecolor='crimson'\n",
    "        ),\n",
    "    )\n",
    "\n",
    "    ax.grid(True)\n",
    "except Exception:\n",
    "    print('Cannot find station {}'.format(station))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe the sea level retreating around 10-Sep 9:00 and then a significant surge after 19:00.\n",
    "The lower winds at beginning of the surge is probably the eye of the hurricane.\n",
    "\n",
    "For our interactive map we will use [`bokeh`](https://bokeh.pydata.org/en/latest) HTML plots instead of the usual raster [`matplotlib`](https://matplotlib.org) ones to enhance the user experience when exploring the graphs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bokeh.resources import CDN\n",
    "from bokeh.plotting import figure\n",
    "from bokeh.embed import file_html\n",
    "from bokeh.models import Range1d, LinearAxis, HoverTool\n",
    "\n",
    "from folium import IFrame\n",
    "\n",
    "# Plot defaults.\n",
    "tools = \"pan,box_zoom,reset\"\n",
    "width, height = 750, 250\n",
    "\n",
    "\n",
    "def make_plot(ssh, wind):\n",
    "    p = figure(toolbar_location='above',\n",
    "               x_axis_type='datetime',\n",
    "               width=width,\n",
    "               height=height,\n",
    "               tools=tools,\n",
    "               title=ssh.name)\n",
    "\n",
    "    p.yaxis.axis_label = 'wind speed (m/s)'\n",
    "\n",
    "    l0 = p.line(\n",
    "        x=wind.index,\n",
    "        y=wind.values,\n",
    "        line_width=5,\n",
    "        line_cap='round',\n",
    "        line_join='round',\n",
    "        legend='wind speed (m/s)',\n",
    "        color='#9900cc',\n",
    "        alpha=0.5,\n",
    "    )\n",
    "\n",
    "    p.extra_y_ranges = {}\n",
    "    p.extra_y_ranges['y2'] = Range1d(\n",
    "        start=-1,\n",
    "        end=3.5\n",
    "    )\n",
    "\n",
    "    p.add_layout(\n",
    "        LinearAxis(\n",
    "            y_range_name='y2',\n",
    "            axis_label='ssh (m)'),\n",
    "        'right'\n",
    "    )\n",
    "\n",
    "    l1 = p.line(\n",
    "        x=ssh.index,\n",
    "        y=ssh.values,\n",
    "        line_width=5,\n",
    "        line_cap='round',\n",
    "        line_join='round',\n",
    "        legend='ssh (m)',\n",
    "        color='#0000ff',\n",
    "        alpha=0.5,\n",
    "        y_range_name='y2',\n",
    "    )\n",
    "\n",
    "    p.legend.location = 'top_left'\n",
    "\n",
    "    p.add_tools(\n",
    "        HoverTool(\n",
    "            tooltips=[\n",
    "                ('wind speed (m/s)', '@y'),\n",
    "            ],\n",
    "            renderers=[l0],\n",
    "        ),\n",
    "        HoverTool(\n",
    "            tooltips=[\n",
    "                ('ssh (m)', '@y'),\n",
    "            ],\n",
    "            renderers=[l1],\n",
    "        ),\n",
    "    )\n",
    "    return p\n",
    "\n",
    "\n",
    "def make_marker(p, location, fname):\n",
    "    html = file_html(p, CDN, fname)\n",
    "    iframe = IFrame(html, width=width+45, height=height+80)\n",
    "\n",
    "    popup = folium.Popup(iframe, max_width=2650)\n",
    "    icon = folium.Icon(color='green', icon='stats')\n",
    "    marker = folium.Marker(location=location,\n",
    "                           popup=popup,\n",
    "                           icon=icon)\n",
    "    return marker"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the final result. Explore the map by clicking on the map features plotted!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import folium\n",
    "from folium.plugins import Fullscreen, MarkerCluster\n",
    "from ioos_tools.ioos import get_coordinates\n",
    "\n",
    "\n",
    "lon = track.centroid.x\n",
    "lat = track.centroid.y\n",
    "\n",
    "m = folium.Map(location=[lat, lon], tiles='OpenStreetMap', zoom_start=4)\n",
    "\n",
    "Fullscreen(position='topright', force_separate_button=True).add_to(m)\n",
    "\n",
    "marker_cluster0 = MarkerCluster(name='Observations')\n",
    "marker_cluster1 = MarkerCluster(name='Past predictions')\n",
    "marker_cluster0.add_to(m)\n",
    "marker_cluster1.add_to(m)\n",
    "\n",
    "\n",
    "url = 'http://oos.soest.hawaii.edu/thredds/wms/hioos/satellite/dhw_5km'\n",
    "w0 = folium.WmsTileLayer(\n",
    "    url,\n",
    "    name='Sea Surface Temperature',\n",
    "    fmt='image/png',\n",
    "    layers='CRW_SST',\n",
    "    attr='PacIOOS TDS',\n",
    "    overlay=True,\n",
    "    transparent=True)\n",
    "\n",
    "w0.add_to(m)\n",
    "\n",
    "url = 'http://hfrnet.ucsd.edu/thredds/wms/HFRNet/USEGC/6km/hourly/RTV'\n",
    "w1 = folium.WmsTileLayer(\n",
    "    url,\n",
    "    name='HF Radar',\n",
    "    fmt='image/png',\n",
    "    layers='surface_sea_water_velocity',\n",
    "    attr='HFRNet',\n",
    "    overlay=True,\n",
    "    transparent=True)\n",
    "\n",
    "w1.add_to(m)\n",
    "\n",
    "\n",
    "def style_function(feature):\n",
    "    return {\n",
    "        'fillOpacity': 0,\n",
    "        'color': 'black',\n",
    "        'stroke': 1,\n",
    "        'weight': 0.5,\n",
    "        'opacity': 0.2,\n",
    "    }\n",
    "\n",
    "\n",
    "# Latest cone prediction.\n",
    "latest = cones[-1]\n",
    "folium.GeoJson(\n",
    "    data=latest.__geo_interface__,\n",
    "    name='Cone prediction as of {}'.format(latest['ADVDATE'].values[0]),\n",
    ").add_to(m)\n",
    "\n",
    "# Past cone predictions.\n",
    "for cone in cones[:-1]:\n",
    "    folium.GeoJson(\n",
    "        data=cone.__geo_interface__,\n",
    "        style_function=style_function,\n",
    "    ).add_to(marker_cluster1)\n",
    "\n",
    "# Latest points prediction.\n",
    "for k, row in pts.iterrows():\n",
    "    date = row['FLDATELBL']\n",
    "    hclass = row['TCDVLP']\n",
    "    location = row['LAT'], row['LON']\n",
    "    popup = '{}<br>{}'.format(date, hclass)\n",
    "    folium.CircleMarker(\n",
    "        location=location,\n",
    "        radius=10,\n",
    "        fill=True,\n",
    "        color=colors[hclass],\n",
    "        popup=popup,\n",
    "    ).add_to(m)\n",
    "\n",
    "# All the points along the track.\n",
    "for point in points:\n",
    "    date = point['FLDATELBL']\n",
    "    hclass = point['TCDVLP']\n",
    "    location = point['LAT'], point['LON']\n",
    "    popup = '{}<br>{}'.format(date, hclass)\n",
    "    folium.CircleMarker(\n",
    "        location=location,\n",
    "        radius=5,\n",
    "        fill=True,\n",
    "        color=colors[hclass],\n",
    "        popup=popup,\n",
    "    ).add_to(m)\n",
    "\n",
    "\n",
    "# Observations.\n",
    "for ssh, wind in zip(ssh_observations, winds_observations):\n",
    "    fname = ssh._metadata['station_code']\n",
    "    location = ssh._metadata['lat'], ssh._metadata['lon']\n",
    "    p = make_plot(ssh, wind)\n",
    "    marker = make_marker(p, location=location, fname=fname)\n",
    "    marker.add_to(marker_cluster0)\n",
    "\n",
    "folium.LayerControl().add_to(m)\n",
    "\n",
    "p = folium.PolyLine(get_coordinates(bbox),\n",
    "                    color='#009933',\n",
    "                    weight=1,\n",
    "                    opacity=0.2)\n",
    "\n",
    "p.add_to(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def embed_map(m):\n",
    "    from IPython.display import HTML\n",
    "\n",
    "    m.save('index.html')\n",
    "    with open('index.html') as f:\n",
    "        html = f.read()\n",
    "\n",
    "    iframe = '<iframe srcdoc=\"{srcdoc}\" style=\"width: 100%; height: 750px; border: none\"></iframe>'\n",
    "    srcdoc = html.replace('\"', '&quot;')\n",
    "    return HTML(iframe.format(srcdoc=srcdoc))\n",
    "\n",
    "\n",
    "embed_map(m)"
   ]
  }
 ],
 "metadata": {
  "_draft": {
   "nbviewer_url": "https://gist.github.com/08bdb4c3f05d8449ded5c01c73238e15"
  },
  "anaconda-cloud": {},
  "gist": {
   "data": {
    "description": "Hurricane Irma GIS map",
    "public": true
   },
   "id": "08bdb4c3f05d8449ded5c01c73238e15"
  },
  "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.5"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}