From dc228d75307ef269cfc37752d2ee4e35a4cab803 Mon Sep 17 00:00:00 2001
From: yutsuo <yutsuo@gmail.com>
Date: Sat, 1 Jun 2019 10:16:24 -0300
Subject: [PATCH] update

---
 Arrays.ipynb      |   94 ++++
 Cartopy-New.ipynb | 1045 ++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 1081 insertions(+), 58 deletions(-)

diff --git a/Arrays.ipynb b/Arrays.ipynb
index 1333cea..064fc0d 100644
--- a/Arrays.ipynb
+++ b/Arrays.ipynb
@@ -180,6 +180,100 @@
     "clevs"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "A = np.ones((5,5))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1., 1., 1., 1., 1.],\n",
+       "       [1., 1., 1., 1., 1.],\n",
+       "       [1., 1., 1., 1., 1.],\n",
+       "       [1., 1., 1., 1., 1.],\n",
+       "       [1., 1., 1., 1., 1.]])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "A[1:4,1:4] = 0"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[1., 1., 1., 1., 1.],\n",
+       "       [1., 0., 0., 0., 1.],\n",
+       "       [1., 0., 0., 0., 1.],\n",
+       "       [1., 0., 0., 0., 1.],\n",
+       "       [1., 1., 1., 1., 1.]])"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "A"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.725 0.99  1.    0.87 ]\n",
+      "[0.725 0.99  1.    0.87 ]\n",
+      "[0.725 0.99  1.    0.87 ]\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampleArr = np.array([0.725, 0.39, 0.99, 1, 0.4, 0.223, 0.87])\n",
+    "\n",
+    "condition = (sampleArr > 0.5)\n",
+    "extracted = np.extract(condition, sampleArr)  # returns [0.725 0.99]\n",
+    "\n",
+    "print(sampleArr[sampleArr > 0.5])\n",
+    "print(sampleArr[condition])\n",
+    "print(extracted)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/Cartopy-New.ipynb b/Cartopy-New.ipynb
index 9745bf8..4378525 100644
--- a/Cartopy-New.ipynb
+++ b/Cartopy-New.ipynb
@@ -9,14 +9,794 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "application/javascript": [
+       "/* Put everything inside the global mpl namespace */\n",
+       "window.mpl = {};\n",
+       "\n",
+       "\n",
+       "mpl.get_websocket_type = function() {\n",
+       "    if (typeof(WebSocket) !== 'undefined') {\n",
+       "        return WebSocket;\n",
+       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
+       "        return MozWebSocket;\n",
+       "    } else {\n",
+       "        alert('Your browser does not have WebSocket support.' +\n",
+       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
+       "              'Firefox 4 and 5 are also supported but you ' +\n",
+       "              'have to enable WebSockets in about:config.');\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
+       "    this.id = figure_id;\n",
+       "\n",
+       "    this.ws = websocket;\n",
+       "\n",
+       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
+       "\n",
+       "    if (!this.supports_binary) {\n",
+       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
+       "        if (warnings) {\n",
+       "            warnings.style.display = 'block';\n",
+       "            warnings.textContent = (\n",
+       "                \"This browser does not support binary websocket messages. \" +\n",
+       "                    \"Performance may be slow.\");\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    this.imageObj = new Image();\n",
+       "\n",
+       "    this.context = undefined;\n",
+       "    this.message = undefined;\n",
+       "    this.canvas = undefined;\n",
+       "    this.rubberband_canvas = undefined;\n",
+       "    this.rubberband_context = undefined;\n",
+       "    this.format_dropdown = undefined;\n",
+       "\n",
+       "    this.image_mode = 'full';\n",
+       "\n",
+       "    this.root = $('<div/>');\n",
+       "    this._root_extra_style(this.root)\n",
+       "    this.root.attr('style', 'display: inline-block');\n",
+       "\n",
+       "    $(parent_element).append(this.root);\n",
+       "\n",
+       "    this._init_header(this);\n",
+       "    this._init_canvas(this);\n",
+       "    this._init_toolbar(this);\n",
+       "\n",
+       "    var fig = this;\n",
+       "\n",
+       "    this.waiting = false;\n",
+       "\n",
+       "    this.ws.onopen =  function () {\n",
+       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
+       "            fig.send_message(\"send_image_mode\", {});\n",
+       "            if (mpl.ratio != 1) {\n",
+       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
+       "            }\n",
+       "            fig.send_message(\"refresh\", {});\n",
+       "        }\n",
+       "\n",
+       "    this.imageObj.onload = function() {\n",
+       "            if (fig.image_mode == 'full') {\n",
+       "                // Full images could contain transparency (where diff images\n",
+       "                // almost always do), so we need to clear the canvas so that\n",
+       "                // there is no ghosting.\n",
+       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "            }\n",
+       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
+       "        };\n",
+       "\n",
+       "    this.imageObj.onunload = function() {\n",
+       "        fig.ws.close();\n",
+       "    }\n",
+       "\n",
+       "    this.ws.onmessage = this._make_on_message_function(this);\n",
+       "\n",
+       "    this.ondownload = ondownload;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_header = function() {\n",
+       "    var titlebar = $(\n",
+       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
+       "        'ui-helper-clearfix\"/>');\n",
+       "    var titletext = $(\n",
+       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
+       "        'text-align: center; padding: 3px;\"/>');\n",
+       "    titlebar.append(titletext)\n",
+       "    this.root.append(titlebar);\n",
+       "    this.header = titletext[0];\n",
+       "}\n",
+       "\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_canvas = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var canvas_div = $('<div/>');\n",
+       "\n",
+       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
+       "\n",
+       "    function canvas_keyboard_event(event) {\n",
+       "        return fig.key_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
+       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
+       "    this.canvas_div = canvas_div\n",
+       "    this._canvas_extra_style(canvas_div)\n",
+       "    this.root.append(canvas_div);\n",
+       "\n",
+       "    var canvas = $('<canvas/>');\n",
+       "    canvas.addClass('mpl-canvas');\n",
+       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
+       "\n",
+       "    this.canvas = canvas[0];\n",
+       "    this.context = canvas[0].getContext(\"2d\");\n",
+       "\n",
+       "    var backingStore = this.context.backingStorePixelRatio ||\n",
+       "\tthis.context.webkitBackingStorePixelRatio ||\n",
+       "\tthis.context.mozBackingStorePixelRatio ||\n",
+       "\tthis.context.msBackingStorePixelRatio ||\n",
+       "\tthis.context.oBackingStorePixelRatio ||\n",
+       "\tthis.context.backingStorePixelRatio || 1;\n",
+       "\n",
+       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
+       "\n",
+       "    var rubberband = $('<canvas/>');\n",
+       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
+       "\n",
+       "    var pass_mouse_events = true;\n",
+       "\n",
+       "    canvas_div.resizable({\n",
+       "        start: function(event, ui) {\n",
+       "            pass_mouse_events = false;\n",
+       "        },\n",
+       "        resize: function(event, ui) {\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "        stop: function(event, ui) {\n",
+       "            pass_mouse_events = true;\n",
+       "            fig.request_resize(ui.size.width, ui.size.height);\n",
+       "        },\n",
+       "    });\n",
+       "\n",
+       "    function mouse_event_fn(event) {\n",
+       "        if (pass_mouse_events)\n",
+       "            return fig.mouse_event(event, event['data']);\n",
+       "    }\n",
+       "\n",
+       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
+       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
+       "    // Throttle sequential mouse events to 1 every 20ms.\n",
+       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
+       "\n",
+       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
+       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
+       "\n",
+       "    canvas_div.on(\"wheel\", function (event) {\n",
+       "        event = event.originalEvent;\n",
+       "        event['data'] = 'scroll'\n",
+       "        if (event.deltaY < 0) {\n",
+       "            event.step = 1;\n",
+       "        } else {\n",
+       "            event.step = -1;\n",
+       "        }\n",
+       "        mouse_event_fn(event);\n",
+       "    });\n",
+       "\n",
+       "    canvas_div.append(canvas);\n",
+       "    canvas_div.append(rubberband);\n",
+       "\n",
+       "    this.rubberband = rubberband;\n",
+       "    this.rubberband_canvas = rubberband[0];\n",
+       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
+       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
+       "\n",
+       "    this._resize_canvas = function(width, height) {\n",
+       "        // Keep the size of the canvas, canvas container, and rubber band\n",
+       "        // canvas in synch.\n",
+       "        canvas_div.css('width', width)\n",
+       "        canvas_div.css('height', height)\n",
+       "\n",
+       "        canvas.attr('width', width * mpl.ratio);\n",
+       "        canvas.attr('height', height * mpl.ratio);\n",
+       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
+       "\n",
+       "        rubberband.attr('width', width);\n",
+       "        rubberband.attr('height', height);\n",
+       "    }\n",
+       "\n",
+       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
+       "    // upon first draw.\n",
+       "    this._resize_canvas(600, 600);\n",
+       "\n",
+       "    // Disable right mouse context menu.\n",
+       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
+       "        return false;\n",
+       "    });\n",
+       "\n",
+       "    function set_focus () {\n",
+       "        canvas.focus();\n",
+       "        canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    window.setTimeout(set_focus, 100);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) {\n",
+       "            // put a spacer in here.\n",
+       "            continue;\n",
+       "        }\n",
+       "        var button = $('<button/>');\n",
+       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
+       "                        'ui-button-icon-only');\n",
+       "        button.attr('role', 'button');\n",
+       "        button.attr('aria-disabled', 'false');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "\n",
+       "        var icon_img = $('<span/>');\n",
+       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
+       "        icon_img.addClass(image);\n",
+       "        icon_img.addClass('ui-corner-all');\n",
+       "\n",
+       "        var tooltip_span = $('<span/>');\n",
+       "        tooltip_span.addClass('ui-button-text');\n",
+       "        tooltip_span.html(tooltip);\n",
+       "\n",
+       "        button.append(icon_img);\n",
+       "        button.append(tooltip_span);\n",
+       "\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    var fmt_picker_span = $('<span/>');\n",
+       "\n",
+       "    var fmt_picker = $('<select/>');\n",
+       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
+       "    fmt_picker_span.append(fmt_picker);\n",
+       "    nav_element.append(fmt_picker_span);\n",
+       "    this.format_dropdown = fmt_picker[0];\n",
+       "\n",
+       "    for (var ind in mpl.extensions) {\n",
+       "        var fmt = mpl.extensions[ind];\n",
+       "        var option = $(\n",
+       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
+       "        fmt_picker.append(option)\n",
+       "    }\n",
+       "\n",
+       "    // Add hover states to the ui-buttons\n",
+       "    $( \".ui-button\" ).hover(\n",
+       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
+       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
+       "    );\n",
+       "\n",
+       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
+       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
+       "    // which will in turn request a refresh of the image.\n",
+       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_message = function(type, properties) {\n",
+       "    properties['type'] = type;\n",
+       "    properties['figure_id'] = this.id;\n",
+       "    this.ws.send(JSON.stringify(properties));\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.send_draw_message = function() {\n",
+       "    if (!this.waiting) {\n",
+       "        this.waiting = true;\n",
+       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    var format_dropdown = fig.format_dropdown;\n",
+       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
+       "    fig.ondownload(fig, format);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
+       "    var size = msg['size'];\n",
+       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
+       "        fig._resize_canvas(size[0], size[1]);\n",
+       "        fig.send_message(\"refresh\", {});\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
+       "    var x0 = msg['x0'] / mpl.ratio;\n",
+       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
+       "    var x1 = msg['x1'] / mpl.ratio;\n",
+       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
+       "    x0 = Math.floor(x0) + 0.5;\n",
+       "    y0 = Math.floor(y0) + 0.5;\n",
+       "    x1 = Math.floor(x1) + 0.5;\n",
+       "    y1 = Math.floor(y1) + 0.5;\n",
+       "    var min_x = Math.min(x0, x1);\n",
+       "    var min_y = Math.min(y0, y1);\n",
+       "    var width = Math.abs(x1 - x0);\n",
+       "    var height = Math.abs(y1 - y0);\n",
+       "\n",
+       "    fig.rubberband_context.clearRect(\n",
+       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
+       "\n",
+       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
+       "    // Updates the figure title.\n",
+       "    fig.header.textContent = msg['label'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
+       "    var cursor = msg['cursor'];\n",
+       "    switch(cursor)\n",
+       "    {\n",
+       "    case 0:\n",
+       "        cursor = 'pointer';\n",
+       "        break;\n",
+       "    case 1:\n",
+       "        cursor = 'default';\n",
+       "        break;\n",
+       "    case 2:\n",
+       "        cursor = 'crosshair';\n",
+       "        break;\n",
+       "    case 3:\n",
+       "        cursor = 'move';\n",
+       "        break;\n",
+       "    }\n",
+       "    fig.rubberband_canvas.style.cursor = cursor;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
+       "    fig.message.textContent = msg['message'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
+       "    // Request the server to send over a new figure.\n",
+       "    fig.send_draw_message();\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
+       "    fig.image_mode = msg['mode'];\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Called whenever the canvas gets updated.\n",
+       "    this.send_message(\"ack\", {});\n",
+       "}\n",
+       "\n",
+       "// A function to construct a web socket function for onmessage handling.\n",
+       "// Called in the figure constructor.\n",
+       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
+       "    return function socket_on_message(evt) {\n",
+       "        if (evt.data instanceof Blob) {\n",
+       "            /* FIXME: We get \"Resource interpreted as Image but\n",
+       "             * transferred with MIME type text/plain:\" errors on\n",
+       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
+       "             * to be part of the websocket stream */\n",
+       "            evt.data.type = \"image/png\";\n",
+       "\n",
+       "            /* Free the memory for the previous frames */\n",
+       "            if (fig.imageObj.src) {\n",
+       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
+       "                    fig.imageObj.src);\n",
+       "            }\n",
+       "\n",
+       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
+       "                evt.data);\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
+       "            fig.imageObj.src = evt.data;\n",
+       "            fig.updated_canvas_event();\n",
+       "            fig.waiting = false;\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        var msg = JSON.parse(evt.data);\n",
+       "        var msg_type = msg['type'];\n",
+       "\n",
+       "        // Call the  \"handle_{type}\" callback, which takes\n",
+       "        // the figure and JSON message as its only arguments.\n",
+       "        try {\n",
+       "            var callback = fig[\"handle_\" + msg_type];\n",
+       "        } catch (e) {\n",
+       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
+       "            return;\n",
+       "        }\n",
+       "\n",
+       "        if (callback) {\n",
+       "            try {\n",
+       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
+       "                callback(fig, msg);\n",
+       "            } catch (e) {\n",
+       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
+       "            }\n",
+       "        }\n",
+       "    };\n",
+       "}\n",
+       "\n",
+       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
+       "mpl.findpos = function(e) {\n",
+       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
+       "    var targ;\n",
+       "    if (!e)\n",
+       "        e = window.event;\n",
+       "    if (e.target)\n",
+       "        targ = e.target;\n",
+       "    else if (e.srcElement)\n",
+       "        targ = e.srcElement;\n",
+       "    if (targ.nodeType == 3) // defeat Safari bug\n",
+       "        targ = targ.parentNode;\n",
+       "\n",
+       "    // jQuery normalizes the pageX and pageY\n",
+       "    // pageX,Y are the mouse positions relative to the document\n",
+       "    // offset() returns the position of the element relative to the document\n",
+       "    var x = e.pageX - $(targ).offset().left;\n",
+       "    var y = e.pageY - $(targ).offset().top;\n",
+       "\n",
+       "    return {\"x\": x, \"y\": y};\n",
+       "};\n",
+       "\n",
+       "/*\n",
+       " * return a copy of an object with only non-object keys\n",
+       " * we need this to avoid circular references\n",
+       " * http://stackoverflow.com/a/24161582/3208463\n",
+       " */\n",
+       "function simpleKeys (original) {\n",
+       "  return Object.keys(original).reduce(function (obj, key) {\n",
+       "    if (typeof original[key] !== 'object')\n",
+       "        obj[key] = original[key]\n",
+       "    return obj;\n",
+       "  }, {});\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
+       "    var canvas_pos = mpl.findpos(event)\n",
+       "\n",
+       "    if (name === 'button_press')\n",
+       "    {\n",
+       "        this.canvas.focus();\n",
+       "        this.canvas_div.focus();\n",
+       "    }\n",
+       "\n",
+       "    var x = canvas_pos.x * mpl.ratio;\n",
+       "    var y = canvas_pos.y * mpl.ratio;\n",
+       "\n",
+       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
+       "                             step: event.step,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "\n",
+       "    /* This prevents the web browser from automatically changing to\n",
+       "     * the text insertion cursor when the button is pressed.  We want\n",
+       "     * to control all of the cursor setting manually through the\n",
+       "     * 'cursor' event from matplotlib */\n",
+       "    event.preventDefault();\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    // Handle any extra behaviour associated with a key event\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.key_event = function(event, name) {\n",
+       "\n",
+       "    // Prevent repeat events\n",
+       "    if (name == 'key_press')\n",
+       "    {\n",
+       "        if (event.which === this._key)\n",
+       "            return;\n",
+       "        else\n",
+       "            this._key = event.which;\n",
+       "    }\n",
+       "    if (name == 'key_release')\n",
+       "        this._key = null;\n",
+       "\n",
+       "    var value = '';\n",
+       "    if (event.ctrlKey && event.which != 17)\n",
+       "        value += \"ctrl+\";\n",
+       "    if (event.altKey && event.which != 18)\n",
+       "        value += \"alt+\";\n",
+       "    if (event.shiftKey && event.which != 16)\n",
+       "        value += \"shift+\";\n",
+       "\n",
+       "    value += 'k';\n",
+       "    value += event.which.toString();\n",
+       "\n",
+       "    this._key_event_extra(event, name);\n",
+       "\n",
+       "    this.send_message(name, {key: value,\n",
+       "                             guiEvent: simpleKeys(event)});\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
+       "    if (name == 'download') {\n",
+       "        this.handle_save(this, null);\n",
+       "    } else {\n",
+       "        this.send_message(\"toolbar_button\", {name: name});\n",
+       "    }\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
+       "    this.message.textContent = tooltip;\n",
+       "};\n",
+       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
+       "\n",
+       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
+       "\n",
+       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
+       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
+       "    // object with the appropriate methods. Currently this is a non binary\n",
+       "    // socket, so there is still some room for performance tuning.\n",
+       "    var ws = {};\n",
+       "\n",
+       "    ws.close = function() {\n",
+       "        comm.close()\n",
+       "    };\n",
+       "    ws.send = function(m) {\n",
+       "        //console.log('sending', m);\n",
+       "        comm.send(m);\n",
+       "    };\n",
+       "    // Register the callback with on_msg.\n",
+       "    comm.on_msg(function(msg) {\n",
+       "        //console.log('receiving', msg['content']['data'], msg);\n",
+       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
+       "        ws.onmessage(msg['content']['data'])\n",
+       "    });\n",
+       "    return ws;\n",
+       "}\n",
+       "\n",
+       "mpl.mpl_figure_comm = function(comm, msg) {\n",
+       "    // This is the function which gets called when the mpl process\n",
+       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
+       "\n",
+       "    var id = msg.content.data.id;\n",
+       "    // Get hold of the div created by the display call when the Comm\n",
+       "    // socket was opened in Python.\n",
+       "    var element = $(\"#\" + id);\n",
+       "    var ws_proxy = comm_websocket_adapter(comm)\n",
+       "\n",
+       "    function ondownload(figure, format) {\n",
+       "        window.open(figure.imageObj.src);\n",
+       "    }\n",
+       "\n",
+       "    var fig = new mpl.figure(id, ws_proxy,\n",
+       "                           ondownload,\n",
+       "                           element.get(0));\n",
+       "\n",
+       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
+       "    // web socket which is closed, not our websocket->open comm proxy.\n",
+       "    ws_proxy.onopen();\n",
+       "\n",
+       "    fig.parent_element = element.get(0);\n",
+       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
+       "    if (!fig.cell_info) {\n",
+       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
+       "        return;\n",
+       "    }\n",
+       "\n",
+       "    var output_index = fig.cell_info[2]\n",
+       "    var cell = fig.cell_info[0];\n",
+       "\n",
+       "};\n",
+       "\n",
+       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
+       "    var width = fig.canvas.width/mpl.ratio\n",
+       "    fig.root.unbind('remove')\n",
+       "\n",
+       "    // Update the output cell to use the data from the current canvas.\n",
+       "    fig.push_to_output();\n",
+       "    var dataURL = fig.canvas.toDataURL();\n",
+       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
+       "    // the notebook keyboard shortcuts fail.\n",
+       "    IPython.keyboard_manager.enable()\n",
+       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
+       "    fig.close_ws(fig, msg);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
+       "    fig.send_message('closing', msg);\n",
+       "    // fig.ws.close()\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
+       "    // Turn the data on the canvas into data in the output cell.\n",
+       "    var width = this.canvas.width/mpl.ratio\n",
+       "    var dataURL = this.canvas.toDataURL();\n",
+       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.updated_canvas_event = function() {\n",
+       "    // Tell IPython that the notebook contents must change.\n",
+       "    IPython.notebook.set_dirty(true);\n",
+       "    this.send_message(\"ack\", {});\n",
+       "    var fig = this;\n",
+       "    // Wait a second, then push the new image to the DOM so\n",
+       "    // that it is saved nicely (might be nice to debounce this).\n",
+       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._init_toolbar = function() {\n",
+       "    var fig = this;\n",
+       "\n",
+       "    var nav_element = $('<div/>')\n",
+       "    nav_element.attr('style', 'width: 100%');\n",
+       "    this.root.append(nav_element);\n",
+       "\n",
+       "    // Define a callback function for later on.\n",
+       "    function toolbar_event(event) {\n",
+       "        return fig.toolbar_button_onclick(event['data']);\n",
+       "    }\n",
+       "    function toolbar_mouse_event(event) {\n",
+       "        return fig.toolbar_button_onmouseover(event['data']);\n",
+       "    }\n",
+       "\n",
+       "    for(var toolbar_ind in mpl.toolbar_items){\n",
+       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
+       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
+       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
+       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
+       "\n",
+       "        if (!name) { continue; };\n",
+       "\n",
+       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
+       "        button.click(method_name, toolbar_event);\n",
+       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
+       "        nav_element.append(button);\n",
+       "    }\n",
+       "\n",
+       "    // Add the status bar.\n",
+       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
+       "    nav_element.append(status_bar);\n",
+       "    this.message = status_bar[0];\n",
+       "\n",
+       "    // Add the close button to the window.\n",
+       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
+       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
+       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
+       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
+       "    buttongrp.append(button);\n",
+       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
+       "    titlebar.prepend(buttongrp);\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._root_extra_style = function(el){\n",
+       "    var fig = this\n",
+       "    el.on(\"remove\", function(){\n",
+       "\tfig.close_ws(fig, {});\n",
+       "    });\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
+       "    // this is important to make the div 'focusable\n",
+       "    el.attr('tabindex', 0)\n",
+       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
+       "    // off when our div gets focus\n",
+       "\n",
+       "    // location in version 3\n",
+       "    if (IPython.notebook.keyboard_manager) {\n",
+       "        IPython.notebook.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "    else {\n",
+       "        // location in version 2\n",
+       "        IPython.keyboard_manager.register_events(el);\n",
+       "    }\n",
+       "\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
+       "    var manager = IPython.notebook.keyboard_manager;\n",
+       "    if (!manager)\n",
+       "        manager = IPython.keyboard_manager;\n",
+       "\n",
+       "    // Check for shift+enter\n",
+       "    if (event.shiftKey && event.which == 13) {\n",
+       "        this.canvas_div.blur();\n",
+       "        event.shiftKey = false;\n",
+       "        // Send a \"J\" for go to next cell\n",
+       "        event.which = 74;\n",
+       "        event.keyCode = 74;\n",
+       "        manager.command_mode();\n",
+       "        manager.handle_keydown(event);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
+       "    fig.ondownload(fig, null);\n",
+       "}\n",
+       "\n",
+       "\n",
+       "mpl.find_output_cell = function(html_output) {\n",
+       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
+       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
+       "    // IPython event is triggered only after the cells have been serialised, which for\n",
+       "    // our purposes (turning an active figure into a static one), is too late.\n",
+       "    var cells = IPython.notebook.get_cells();\n",
+       "    var ncells = cells.length;\n",
+       "    for (var i=0; i<ncells; i++) {\n",
+       "        var cell = cells[i];\n",
+       "        if (cell.cell_type === 'code'){\n",
+       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
+       "                var data = cell.output_area.outputs[j];\n",
+       "                if (data.data) {\n",
+       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
+       "                    data = data.data;\n",
+       "                }\n",
+       "                if (data['text/html'] == html_output) {\n",
+       "                    return [cell, data, j];\n",
+       "                }\n",
+       "            }\n",
+       "        }\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "// Register the function which deals with the matplotlib target/channel.\n",
+       "// The kernel may be null if the page has been refreshed.\n",
+       "if (IPython.notebook.kernel != null) {\n",
+       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
+       "}\n"
+      ],
       "text/plain": [
-       "<Figure size 600x400 with 1 Axes>"
+       "<IPython.core.display.Javascript object>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<img src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAA8AAAALQCAYAAABfdxm0AAAKjklEQVR4nO3BMQEAAADCoPVP7W8GoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIA3NUYAAd1QgUwAAAAASUVORK5CYII=\" width=\"960\">"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
      },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -25,12 +805,21 @@
     "# import cartopy.feature as cf\n",
     "import matplotlib.pyplot as plt\n",
     "# import numpy as np\n",
-    "%matplotlib inline\n",
+    "\n",
+    "# import matplotlib.pyplot as plt\n",
+    "# from matplotlib import cm\n",
+    "import numpy as np\n",
+    "import h5py as h5py\n",
+    "# import cartopy.crs as ccrs\n",
+    "import cartopy.feature as cfeature\n",
+    "from cartopy.io.shapereader import Reader\n",
+    "from cartopy.feature import ShapelyFeature\n",
+    "\n",
+    "%matplotlib notebook\n",
     "\n",
     "projection = ccrs.PlateCarree()\n",
     "\n",
-    "# fig = plt.figure(dpi=150)\n",
-    "fig = plt.figure(dpi=100)\n",
+    "fig = plt.figure(dpi=150)\n",
     "\n",
     "ax = plt.axes(projection = projection)\n",
     "\n",
@@ -70,7 +859,7 @@
       "\n",
       "## ds ##:\n",
       "\n",
-      "<osgeo.gdal.Dataset; proxy of <Swig Object of type 'GDALDatasetShadow *' at 0x7fd17a4b9ab0> >\n",
+      "<osgeo.gdal.Dataset; proxy of <Swig Object of type 'GDALDatasetShadow *' at 0x7f8640535bd0> >\n",
       "\n",
       "\n",
       "## data ##:\n",
@@ -175,12 +964,7 @@
       "\n",
       "## projcs ##:\n",
       "\n",
-      "32723\n",
-      "\n",
-      "\n",
-      "## image_projection ##:\n",
-      "\n",
-      "_EPSGProjection(32723)\n"
+      "32723\n"
      ]
     }
    ],
@@ -188,8 +972,8 @@
     "projcs = inproj.GetAuthorityCode('PROJCS')\n",
     "print('\\n\\n## projcs ##:\\n\\n' + str(projcs))\n",
     "\n",
-    "image_projection = ccrs.epsg(projcs)\n",
-    "print('\\n\\n## image_projection ##:\\n\\n' + str(image_projection))"
+    "# image_projection = ccrs.epsg(projcs)\n",
+    "# print('\\n\\n## image_projection ##:\\n\\n' + str(image_projection))"
    ]
   },
   {
@@ -205,24 +989,18 @@
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "# subplot_kw = dict(projection=image_projection)\n",
-    "# fig, ax = plt.subplots(subplot_kw=subplot_kw)\n",
-    "\n",
-    "# image_extent = (gt[0], gt[0] + ds.RasterXSize * gt[1], gt[3] + ds.RasterYSize * gt[5], gt[3])\n",
-    "\n",
-    "# img = ax.imshow(data[:3, :, :].transpose((1, 2, 0)), extent=extent, origin='upper')\n",
-    "ax.imshow(img, extent=extent, origin='upper', transform=ccrs.PlateCarree())\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "\n",
+      "## get_extent() ##:\n",
+      "\n",
+      "(-44.996, -44.009, -2.805, -1.8090000000000002)\n"
+     ]
+    },
     {
      "data": {
       "image/png": "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\n",
@@ -234,24 +1012,13 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "\n",
-      "## get_extent() ##:\n",
-      "\n",
-      "(-44.996, -44.009, -2.805, -1.8090000000000002)\n"
-     ]
     }
    ],
    "source": [
-    "import cartopy.crs as ccrs\n",
+    "# import cartopy.crs as ccrs\n",
     "# import cartopy.feature as cf\n",
-    "import matplotlib.pyplot as plt\n",
-    "%matplotlib inline\n",
+    "# import matplotlib.pyplot as plt\n",
+    "# %matplotlib inline\n",
     "\n",
     "projection = ccrs.PlateCarree()\n",
     "\n",
@@ -269,25 +1036,187 @@
     "ax.set_extent(extent, crs=ccrs.PlateCarree())\n",
     "img = plt.imread(fname)\n",
     "ax.imshow(img, extent=extent, origin='upper', transform=ccrs.PlateCarree())\n",
-    "plt.show()\n",
+    "\n",
+    "# plt.show()\n",
     "\n",
     "print('\\n\\n## get_extent() ##:\\n\\n' + str(ax.get_extent()))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([[-179.95, -179.85, -179.75, ...,  179.75,  179.85,  179.95],\n",
+       "        [-179.95, -179.85, -179.75, ...,  179.75,  179.85,  179.95],\n",
+       "        [-179.95, -179.85, -179.75, ...,  179.75,  179.85,  179.95],\n",
+       "        ...,\n",
+       "        [-179.95, -179.85, -179.75, ...,  179.75,  179.85,  179.95],\n",
+       "        [-179.95, -179.85, -179.75, ...,  179.75,  179.85,  179.95],\n",
+       "        [-179.95, -179.85, -179.75, ...,  179.75,  179.85,  179.95]],\n",
+       "       dtype=float32),\n",
+       " array([[-89.95, -89.95, -89.95, ..., -89.95, -89.95, -89.95],\n",
+       "        [-89.85, -89.85, -89.85, ..., -89.85, -89.85, -89.85],\n",
+       "        [-89.75, -89.75, -89.75, ..., -89.75, -89.75, -89.75],\n",
+       "        ...,\n",
+       "        [ 89.75,  89.75,  89.75, ...,  89.75,  89.75,  89.75],\n",
+       "        [ 89.85,  89.85,  89.85, ...,  89.85,  89.85,  89.85],\n",
+       "        [ 89.95,  89.95,  89.95, ...,  89.95,  89.95,  89.95]],\n",
+       "       dtype=float32))"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "import matplotlib.pyplot as plt\n",
-    "from matplotlib import cm\n",
-    "import numpy as np\n",
-    "import h5py as h5py\n",
-    "import cartopy.crs as ccrs\n",
-    "import cartopy.feature as cfeature\n",
-    "from cartopy.io.shapereader import Reader\n",
-    "from cartopy.feature import ShapelyFeature"
+    "# import matplotlib.pyplot as plt\n",
+    "# from matplotlib import cm\n",
+    "# import numpy as np\n",
+    "# import h5py as h5py\n",
+    "# import cartopy.crs as ccrs\n",
+    "# import cartopy.feature as cfeature\n",
+    "# from cartopy.io.shapereader import Reader\n",
+    "# from cartopy.feature import ShapelyFeature\n",
+    "# %matplotlib inline\n",
+    "\n",
+    "hdf5 = '/notebooks/resources/3B-MO.MS.MRG.3IMERG.20190101-S000000-E235959.01.V06A.HDF5'\n",
+    "dataset = h5py.File(hdf5,'r')\n",
+    "\n",
+    "precip = dataset['Grid/precipitation'][:]\n",
+    "precip = np.transpose(precip[0])\n",
+    "\n",
+    "theLats = dataset['Grid/lat'][:]\n",
+    "theLons = dataset['Grid/lon'][:]\n",
+    "\n",
+    "clevs = np.arange(0,1.26,0.125)\n",
+    "\n",
+    "x, y = np.float32(np.meshgrid(theLons, theLats))\n",
+    "\n",
+    "masked_array = np.ma.masked_where(precip < 0,precip)\n",
+    "\n",
+    "cmap = 'nipy_spectral'\n",
+    "\n",
+    "plt.title('January 2019 Monthly Average Rain Rate')\n",
+    "\n",
+    "font = {'weight' : 'bold', 'size' : 3}\n",
+    "\n",
+    "plt.rc('font', **font)\n",
+    "\n",
+    "cs = ax.contourf(x, y, precip, clevs, transform=ccrs.PlateCarree(), cmap=cmap)\n",
+    "# cs = ax.contourf(x, y, precip, transform=ccrs.PlateCarree(), cmap=cmap)\n",
+    "\n",
+    "sm = plt.cm.ScalarMappable(cmap=cmap,norm=plt.Normalize(0,1))\n",
+    "sm._A = []\n",
+    "plt.colorbar(sm, ax=ax, label='mm/h', shrink=0.5)\n",
+    "\n",
+    "# plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-89.85, -89.85, -89.85, ..., -89.85, -89.85, -89.85], dtype=float32)"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "x[1500]\n",
+    "y[1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-179.95, -179.85, -179.75, ...,  179.75,  179.85,  179.95],\n",
+       "      dtype=float32)"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "theLons"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([-89.95, -89.85, -89.75, ...,  89.75,  89.85,  89.95], dtype=float32)"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "theLats"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ValueError",
+     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-27-098a7cc4c66d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# [-44.996, -44.009, -2.805, -1.809]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mcondition\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mtheLats\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m44\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m45\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mextracted\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mextract\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcondition\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtheLats\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
+     ]
+    }
+   ],
+   "source": [
+    "# [-44.996, -44.009, -2.805, -1.809]\n",
+    "\n",
+    "condition = (theLats > -44 < -45)\n",
+    "extracted = np.extract(condition, theLats)\n",
+    "\n",
+    "print(theLats[theLats > 0.5])\n",
+    "print(theLats[condition])\n",
+    "print(extracted)"
    ]
   },
   {