multivarible-final_submission.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lucien Gaitskell - Multivariable - Final Project.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "L0XZ4BSAakNY",
        "FLwCzPyohtUG",
        "entu9CcgcChM",
        "7B2u8e3ogx2v"
      ],
      "include_colab_link": true
    },
    "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.8.2"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/luciengaitskell/surfacegrad/blob/master/multivarible-final_submission.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "f55dgXUdK1gX"
      },
      "source": [
        "# Land Gradients\n",
        "## Multivariable Final Project\n",
        "### By Lucien Gaitskell '21\n",
        "---\n",
        "\n",
        "[Process Document](https://docs.google.com/document/d/1SkBM31T1R7t_NSwYksWuJIlWApiOJ3zho64ikw_aIK4/edit?usp=sharing)\n",
        "\n",
        "Highlight flat regions and gradients in similar directions\n",
        "\n",
        "Could be used to find:\n",
        "- areas viable for houses\n",
        "- bodies of water, rivers\n",
        "- channels in mountains\n",
        "- large roads\n",
        "\n",
        "**NOTE:** Please read information about plotting in subsequent sections"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "VtQuDv7OVC5F",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "\n",
        "# 1/3 arcsecond data from USGS\n",
        "DATA_URLS = {\n",
        "        'RI': \"https://prd-tnm.s3.amazonaws.com/StagedProducts/Elevation/13/TIFF/n42w072/USGS_13_n42w072.tif\",\n",
        "        'CA': \"https://prd-tnm.s3.amazonaws.com/StagedProducts/Elevation/13/TIFF/n38w122/USGS_13_n38w122.tif\",\n",
        "        'SOCAL': \"https://prd-tnm.s3.amazonaws.com/StagedProducts/Elevation/13/TIFF/n37w119/USGS_13_n37w119.tif\",\n",
        "        'MORESOCAL': \"https://prd-tnm.s3.amazonaws.com/StagedProducts/Elevation/13/TIFF/n36w119/USGS_13_n36w119.tif\",\n",
        "}"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "uCiHnZXsK_KD"
      },
      "source": [
        "## Supporting Code"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "L0XZ4BSAakNY"
      },
      "source": [
        "### Data Retrieval / Processing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "MbxMu_0DWoux",
        "colab": {},
        "outputId": "ad4f6518-c558-45a8-f2de-11ff09e1a205"
      },
      "source": [
        "import re\n",
        "import urllib.request\n",
        "%pip install tqdm\n",
        "from tqdm.notebook import tqdm"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: tqdm in /Users/luciengaitskell/.local/share/virtualenvs/multi-topological-BYVTV916/lib/python3.8/site-packages (4.45.0)\n",
            "Note: you may need to restart the kernel to use updated packages.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "dykYVuFzWWfx",
        "colab": {}
      },
      "source": [
        "def detect_latlon(res_url: str) -> (int, int):\n",
        "    \"\"\"\n",
        "    Detect the reference latitude and longitude from a USGS resource url.\n",
        "    \"\"\"\n",
        "    l_raw = re.search('[ns]\\d\\d[we]\\d\\d\\d', res_url).group(0)\n",
        "    if l_raw[0] == 'n':\n",
        "        lat = 1\n",
        "    elif l_raw[0] == 's':\n",
        "        lat = -1\n",
        "\n",
        "    lat *= int(l_raw[1:3])\n",
        "\n",
        "    if l_raw[3] == 'e':\n",
        "        lon = 1\n",
        "    elif l_raw[3] == 'w':\n",
        "        lon = -1\n",
        "\n",
        "    lon *= int(l_raw[4:])\n",
        "    return lat, lon"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "AsXPp9pwazf7",
        "colab": {}
      },
      "source": [
        "def download_file(res_url) -> str:\n",
        "    \"\"\" Download file to temp location and return file path. \"\"\"\n",
        "    with tqdm(unit_scale=True) as pbar:\n",
        "        def _dl_report(b, bsize, tsize):\n",
        "            if tsize is not None:\n",
        "                pbar.total = tsize\n",
        "            pbar.update(b * bsize - pbar.n)\n",
        "        fname, headers = urllib.request.urlretrieve(res_url, reporthook=_dl_report)\n",
        "        return fname"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "FLwCzPyohtUG"
      },
      "source": [
        "### Gradients"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "NkJWLjiShyOb",
        "colab": {}
      },
      "source": [
        "def calc_gradient(A, axis):\n",
        "    \"\"\" Calculate gradients at all points in a matrix along specified axis. \"\"\"\n",
        "    \n",
        "    # Get first and last row / col and expand dimensions to match original\n",
        "    if axis == 0:  # x\n",
        "        prep = np.expand_dims(A[0, :], axis=0)  # [a,b,c,...] -> [[a,b,c,...]]\n",
        "        app = np.expand_dims(A[-1, :], axis=0)\n",
        "    elif axis == 1:  # y\n",
        "        prep = np.expand_dims(A[:, 0], axis=1)  # [a,b,c,...] -> [[a],[b],[c],...]\n",
        "        app = np.expand_dims(A[:, -1], axis=1)\n",
        "    else:\n",
        "        raise ValueError\n",
        "\n",
        "    # Take difference with extra first and last row / col\n",
        "    D = np.diff(A, axis=axis, prepend=prep, append=app)  # Take difference between adjacent elements\n",
        "\n",
        "    # Take sum of adjacent rows / col\n",
        "    if axis == 0:  # x\n",
        "        B = D[:-1] + D[1:]\n",
        "    elif axis == 1:  # y\n",
        "        B = D[:, :-1] + D[:, 1:]\n",
        "\n",
        "    return B / 2  # Complete formula"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "B0uk4_eoaq8Q"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "## Example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "X3yoOdOyWeoc",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "entu9CcgcChM"
      },
      "source": [
        "### Loading and Processing\n",
        "\n",
        "Use my helper functions to download the specificied data from the known URL. The lat & lon is saved, and the TIFF file is downloaded, then loaded by `tifffile`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "code",
        "colab_type": "code",
        "id": "qNWg-4cab_w-",
        "outputId": "57804154-cee6-42a9-b9f1-5698787fc6f1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 176
        }
      },
      "source": [
        "%pip install tifffile\n",
        "from tifffile import imread  # Used to read `tif` files from USGS"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: tifffile in /Users/luciengaitskell/.local/share/virtualenvs/multi-topological-BYVTV916/lib/python3.8/site-packages (2020.2.16)\n",
            "Requirement already satisfied: imagecodecs>=2020.1.31 in /Users/luciengaitskell/.local/share/virtualenvs/multi-topological-BYVTV916/lib/python3.8/site-packages (from tifffile) (2020.2.18)\n",
            "Requirement already satisfied: numpy>=1.15.1 in /Users/luciengaitskell/.local/share/virtualenvs/multi-topological-BYVTV916/lib/python3.8/site-packages (from tifffile) (1.18.3)\n",
            "Note: you may need to restart the kernel to use updated packages.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zbzrMcWTkLu1",
        "colab_type": "text"
      },
      "source": [
        "The data is usually 250-500 MB, so this will take some time."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D1PkO6XWkLu2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Location:\n",
        "    \"\"\" Contain geographic data of a specific location, and associate calculations \"\"\"\n",
        "    \n",
        "    def __load_tiff(self, loc_name: str):\n",
        "        \"\"\" Load data from remote TIF file. \"\"\"\n",
        "        url = DATA_URLS[loc_name]  # Grab URL from known sources based on name\n",
        "        self.lat, self.lon = detect_latlon(url)  # Detect latitude and longitude from URL content\n",
        "        self.orig_tiff = imread(download_file(url))  # Download file and load TIF directly\n",
        "        \n",
        "        # Ensure data is in standard range.\n",
        "        ## Set 'empty' pixels to sea level:\n",
        "        self.orig_tiff[self.orig_tiff < -10e20] = 0\n",
        "        self.tif = self.orig_tiff.copy()\n",
        "    \n",
        "    def __create_xy(self):\n",
        "        \"\"\" Create matching x, y 1D vectors for 2D z-axis data.  \"\"\"\n",
        "        self.y, self.x = np.arange(self.tif.shape[0]), np.arange(self.tif.shape[1])  # data in lat, lon\n",
        "        self.x = self.x.astype('float64')\n",
        "        self.y = self.y.astype('float64')\n",
        "        \n",
        "        # --- Scale given x,y values into meters --- #\n",
        "        assert self.orig_tiff.shape[0] == self.orig_tiff.shape[1]  # Currently only supports same dims\n",
        "        # Create scaling factor for converting single latitude step to meters\n",
        "        self.SCALE = 1852 * 60 / self.orig_tiff.shape[0]  # (m / nmi) * (nmi / deg) / (num_steps)\n",
        "        # @ max steps, num_steps == 1 deg latitude\n",
        "\n",
        "        # Scale y values appropriately:\n",
        "        self.y_m_orig = self.y * self.SCALE  # y * (nmi / deg) * (m / nmi)\n",
        "\n",
        "        # Scale x values appropriately, with standard scale and including distortion\n",
        "        self.x_m_orig = (self.x * self.SCALE  # x * (nmi / deg) * (m / nmi)\n",
        "                         * np.cos(  # Use cosine for distortion component\n",
        "                              np.radians(self.lat)  # Determine rad lat at corner point (approx)\n",
        "                           )\n",
        "                         )\n",
        "    def __interp_xy(self):\n",
        "        \"\"\" Create new set of x values at same spacing as latitude. \"\"\"\n",
        "        num_x = np.floor(np.max(self.x_m_orig) / self.SCALE)  # Determine maximum x value\n",
        "        self.out_x = np.arange(0, num_x)  # Create even spaced range up to maximum\n",
        "        \n",
        "        x_map, y_map = np.meshgrid(self.out_x, self.y)  # Create final meshgrid for mapped points\n",
        "        \n",
        "        # -- Interpolate z values at new specified x meter spacing from existing meter values --- #\n",
        "        # Operate over each latitude level to create new interpolated z values\n",
        "        self.out_z = np.array([np.interp(\n",
        "                                  self.out_x*self.SCALE,  # Point to map to (index times scaling)\n",
        "                                  self.x_m_orig,     # X meter positions of existing z data\n",
        "                                  self.tif[i]        # Existing/original z data\n",
        "                                ) for i in range(self.x_m_orig.shape[0])])\n",
        "        \n",
        "    def __get_gradient(self):\n",
        "        \"\"\" Use my gradient calculation to determine magnitude of gradient. \"\"\"\n",
        "        gradient = (calc_gradient(self.out_z, 0), calc_gradient(self.out_z, 1))  # vector\n",
        "\n",
        "        self.gradient_mag = np.sqrt(np.square(gradient[0]) * np.square(gradient[1]))  # scalar\n",
        "        self.gradient_dir = np.arctan2(*gradient)\n",
        "\n",
        "    def __init__(self, loc_name, info=False):\n",
        "        \"\"\" Create new location.\n",
        "        \n",
        "        @param loc_name (str): name of location to load\n",
        "        @param info (bool, default=False): print state information while operating\n",
        "        \"\"\"\n",
        "        self.__load_tiff(loc_name)\n",
        "        if info: print(\"Scaling...\")\n",
        "        self.__create_xy()\n",
        "        if info: print(\"Interpolating...\")\n",
        "        self.__interp_xy()\n",
        "        if info: print(\"Gradient...\")\n",
        "        self.__get_gradient()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4jFZJyX4iQsW",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "mgEl0ANCiWTu"
      },
      "source": [
        "### Graphing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "JDtHulDWLbXS",
        "colab": {},
        "outputId": "8a1a2659-fa5c-40e6-e5c4-fcedea500af9"
      },
      "source": [
        "%pip install vispy\n",
        "import vispy\n",
        "from vispy import app, scene, color"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: vispy in /Users/luciengaitskell/.local/share/virtualenvs/multi-topological-BYVTV916/lib/python3.8/site-packages (0.6.4)\n",
            "Requirement already satisfied: numpy in /Users/luciengaitskell/.local/share/virtualenvs/multi-topological-BYVTV916/lib/python3.8/site-packages (from vispy) (1.18.3)\n",
            "Requirement already satisfied: freetype-py in /Users/luciengaitskell/.local/share/virtualenvs/multi-topological-BYVTV916/lib/python3.8/site-packages (from vispy) (2.1.0.post1)\n",
            "Note: you may need to restart the kernel to use updated packages.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "Ub-4o0OYiXC4",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "EK5XzYC_tinM"
      },
      "source": [
        "#### Interactive 3D\n",
        "**Does not appear** to operate in Colab, however will display in local Jupyter session.\n",
        "\n",
        "Provides interactive experience to view colored gradients based on angle. Can view full map region.\n",
        "\n",
        "- Gradients are colored based on x/y angle, using HSV colorwheel\n",
        "- Gradients are transparent above a threshold\n",
        "- Vispy view control:\n",
        "    - LMB: orbits the view around its center point.\n",
        "    - RMB or scroll: change scale_factor (i.e. zoom level)\n",
        "    - SHIFT + LMB: translate the center point\n",
        "    - SHIFT + RMB: change FOV\n",
        "\n",
        "**NOTE:** `InteractivePlot.show()` will require some time (<1 min) to populate image. The black box is NORMAL"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "BuUntwRNiXVx",
        "colab": {}
      },
      "source": [
        "class InteractivePlot:\n",
        "    \"\"\" A Vispy based plotter for `Location`s. \"\"\"\n",
        "    \n",
        "    def __init__(self, loc: Location):\n",
        "        \"\"\" Create plot object\n",
        "        \n",
        "        @param loc (Location): The location to plot\n",
        "        \"\"\"\n",
        "        \n",
        "        self.canvas = None\n",
        "        \n",
        "        # Downsample data in order to plot full region faster (~100x)\n",
        "        downsample = 10\n",
        "\n",
        "        # Create new, smaller arrays:\n",
        "        self.z_v = loc.out_z[::downsample, ::downsample]\n",
        "        self.y_v = loc.y[::downsample]\n",
        "        self.x_v = loc.out_x[::downsample]\n",
        "        self.gd_dir = loc.gradient_dir[::downsample, ::downsample]\n",
        "        self.gd_mag = loc.gradient_mag[::downsample, ::downsample]\n",
        "        \n",
        "        self.color_source = self.gd_dir  # Use gradient direction for color source\n",
        "\n",
        "        # Scale color to max\n",
        "        self.color_source = self.color_source/np.abs(np.max(self.color_source))\n",
        "\n",
        "    def plot(self):\n",
        "        \"\"\" Set up plot (canvas, camera, colormap, etc). \"\"\"\n",
        "        \n",
        "        # Setup canvas and camera:\n",
        "        self.canvas = scene.SceneCanvas(bgcolor='w')\n",
        "        view = self.canvas.central_widget.add_view()\n",
        "        view.camera = scene.TurntableCamera(up='z', fov=60)\n",
        "        \n",
        "        c = color.get_colormap('hsv').map(self.color_source).reshape(self.color_source.shape + (-1,))\n",
        "        c[self.gd_mag > 0.3, 3] = 0  # Remove color from points of high gradient magnitude\n",
        "        c = c.flatten().tolist()\n",
        "        c=list(map(lambda x,y,z,w:(x,y,z,w), c[0::4],c[1::4],c[2::4],c[3::4]))\n",
        "        \n",
        "        # Create surface:\n",
        "        p1 = scene.visuals.SurfacePlot(x=self.y_v, y=self.x_v, z=self.z_v)\n",
        "        p1.mesh_data.set_vertex_colors(c)  # add colors\n",
        "        view.add(p1)\n",
        "\n",
        "        axis = scene.visuals.XYZAxis(parent=view.scene)  # Add reference axes\n",
        "        \n",
        "    def show(self):\n",
        "        \"\"\"\n",
        "        Display plot!\n",
        "        \n",
        "        This will take some time (<30 sec) to display properly.\n",
        "        Please zoom out once loaded to find the region.\n",
        "        \"\"\"\n",
        "        self.canvas.show()\n",
        "    \n",
        "    @classmethod\n",
        "    def from_loc_name(cls, loc_name):\n",
        "        \"\"\" Run all basic methods for a given location name (simplifying usage). \"\"\"\n",
        "        print(\"Downloading '{}'\".format(loc_name))\n",
        "        loc = Location(loc_name, info=True)\n",
        "        print(\"Setup plot @ {}, {} (lat, lon).\".format(loc.lat, loc.lon))\n",
        "        p = cls(loc)\n",
        "        p.plot()\n",
        "        p.show()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UtjCIfoGkLvD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FsAsp6sVkLvF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "efjMbtjpkLvH",
        "colab_type": "text"
      },
      "source": [
        "##### Example plots:\n",
        "Please read notes above about timing.\n",
        "If executing multiple at once, `.show()` will operate asyncronously, but will not function properly until all plots have sucessfully been displayed.\n",
        "\n",
        "After starting... go get yourself some more coffee"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GB1eaXQTkLvI",
        "colab_type": "code",
        "colab": {
          "referenced_widgets": [
            "c4aeae0633fd43638506bfb39133fd1b",
            "45276586ebfc4e228a968bdba82360b1"
          ]
        },
        "outputId": "e7070376-dfe3-4390-bce9-89edbeea5647"
      },
      "source": [
        "InteractivePlot.from_loc_name(\"CA\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading 'CA'\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "c4aeae0633fd43638506bfb39133fd1b",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Scaling...\n",
            "Interpolating...\n",
            "Gradient...\n",
            "Setup plot @ 38, -122 (lat, lon).\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "45276586ebfc4e228a968bdba82360b1",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "VispyWidget(height=600, width=800)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8R6goL5JkLvO",
        "colab_type": "code",
        "colab": {
          "referenced_widgets": [
            "0ca2c43eed174d0eb3e75e3bea6e7ef8",
            "1a6102479f5e4231b6c390ac4276ba92"
          ]
        },
        "outputId": "89a2c243-375f-48e1-b52d-880234017857"
      },
      "source": [
        "InteractivePlot.from_loc_name(\"SOCAL\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading 'SOCAL'\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "0ca2c43eed174d0eb3e75e3bea6e7ef8",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Scaling...\n",
            "Interpolating...\n",
            "Gradient...\n",
            "Setup plot @ 37, -119 (lat, lon).\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "1a6102479f5e4231b6c390ac4276ba92",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "VispyWidget(height=600, width=800)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SVwwOe2ykLvR",
        "colab_type": "code",
        "colab": {
          "referenced_widgets": [
            "f6c1f587708549519c01ef0a835711ef",
            "7b9e1cdf96ef49c599d8f89b9ae2c1b0"
          ]
        },
        "outputId": "b285e98d-db02-4c35-f297-3eee87d20c0e"
      },
      "source": [
        "InteractivePlot.from_loc_name(\"MORESOCAL\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading 'MORESOCAL'\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "f6c1f587708549519c01ef0a835711ef",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Scaling...\n",
            "Interpolating...\n",
            "Gradient...\n",
            "Setup plot @ 36, -119 (lat, lon).\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "7b9e1cdf96ef49c599d8f89b9ae2c1b0",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "VispyWidget(height=600, width=800)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": false,
        "id": "QnKJJ5NRkLvT",
        "colab_type": "code",
        "colab": {
          "referenced_widgets": [
            "d2873a75dcfe44e996576938431b2203",
            "e0eeebff1d164c5fa2e666c1e542c404"
          ]
        },
        "outputId": "e9854123-78d1-451a-ad28-35c625d44809"
      },
      "source": [
        "InteractivePlot.from_loc_name(\"RI\")"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Downloading 'RI'\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "d2873a75dcfe44e996576938431b2203",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "HBox(children=(FloatProgress(value=1.0, bar_style='info', max=1.0), HTML(value='')))"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Scaling...\n",
            "Interpolating...\n",
            "Gradient...\n",
            "Setup plot @ 42, -72 (lat, lon).\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "e0eeebff1d164c5fa2e666c1e542c404",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "VispyWidget(height=600, width=800)"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BmQXDUmjkLvV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}