Andromeda_IMG.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cd1c2622ed4247858b3226a913c69f17",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FileUpload(value={}, accept='*.csv', description='Upload file', style=ButtonStyle(button_color='lightblue'))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script>\n",
       "code_show=true; \n",
       "function code_toggle() {\n",
       " if (code_show){\n",
       " $('div.input').hide();\n",
       " } else {\n",
       " $('div.input').show();\n",
       " }\n",
       " code_show = !code_show\n",
       "} \n",
       "$( document ).ready(code_toggle);\n",
       "</script>\n",
       "\n",
       "To toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>."
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "import random\n",
    "import os\n",
    "import re\n",
    "import cv2\n",
    "from skimage.transform import resize\n",
    "import csv\n",
    "from functools import partial\n",
    "from tqdm import tqdm\n",
    "\n",
    "from os import listdir\n",
    "from os.path import isfile, join\n",
    "from math import isnan\n",
    "\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.manifold import MDS\n",
    "import sklearn.metrics.pairwise\n",
    "from sklearn.metrics import silhouette_score\n",
    "\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.offsetbox import OffsetImage, AnnotationBbox\n",
    "from matplotlib.patches import FancyBboxPatch\n",
    "from matplotlib.widgets import Slider, Button\n",
    "\n",
    "import ipyplot\n",
    "import io\n",
    "import urllib.request\n",
    "\n",
    "from IPython.display import HTML, Javascript, display\n",
    "import ipywidgets as widgets\n",
    "from ipywidgets import interact, Layout, Button, GridBox, ButtonStyle\n",
    "\n",
    "w = widgets.IntSlider()\n",
    "uploader = widgets.FileUpload(\n",
    "    accept='*.csv',  # Accepted file extension e.g. '.txt', '.pdf', 'image/*', 'image/*,.pdf'\n",
    "    multiple=False,  # True to accept multiple files upload else False\n",
    "    description='Upload file',\n",
    "    style=ButtonStyle(button_color='lightblue')\n",
    ")\n",
    "\n",
    "display(uploader)\n",
    "\n",
    "# def run_all(ev):\n",
    "#     display(Javascript('IPython.notebook.execute_cells_below()'))\n",
    "#     #display(Javascript(\"Jupyter.notebook.execute_cell(2)\"))\n",
    "\n",
    "# button = widgets.Button(description=\"Create next input\")\n",
    "# button.on_click(run_all)\n",
    "# display(button)\n",
    "\n",
    "HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    " if (code_show){\n",
    " $('div.input').hide();\n",
    " } else {\n",
    " $('div.input').show();\n",
    " }\n",
    " code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "\n",
    "To toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>.''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "IPython.notebook.execute_cells_below()"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0d5f82dfe4d04566b9b24444284484f6",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Button(description='Launch Andromeda', style=ButtonStyle(button_color='lightblue'))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def run_all(ev):\n",
    "    display(Javascript('IPython.notebook.execute_cells_below()'))\n",
    "    #display(Javascript(\"Jupyter.notebook.execute_cell(2)\"))\n",
    "\n",
    "button = widgets.Button(description=\"Launch Andromeda\",\n",
    "                       style=ButtonStyle(button_color='lightblue'))\n",
    "button.on_click(run_all)\n",
    "display(button)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "try:    \n",
    "    input_file = list(uploader.value.values())[0]\n",
    "    content = input_file['content']\n",
    "    content = io.StringIO(content.decode('utf-8'))\n",
    "    df = pd.read_csv(content)\n",
    "    #df.rename(columns = {'Image_Label':'Name'}, inplace=True)\n",
    "    df.set_index('Image_Label', inplace=True)\n",
    "\n",
    "    label_names = df.index.tolist()\n",
    "    image_paths = {}\n",
    "    for name in label_names:\n",
    "        image_paths[name] = df['Image_Link'][name]\n",
    "\n",
    "    df = df.loc[:, ~df.columns.isin(['Image_Link','Species','User','Date','Time','Annotations','Hex_Color_Code'])]\n",
    "    df_numeric = df.select_dtypes(include='number')  #'int32' or 'int64' or 'float32' or 'float64'\n",
    "    df_numeric = df_numeric.loc[:, (df_numeric != df_numeric.iloc[0]).any()] \n",
    "    df_category = df.select_dtypes(exclude='number') #'object'\n",
    "    normalized_df = (df_numeric - df_numeric.mean()) / df_numeric.std()\n",
    "    min_weight, max_weight = 0.00001, 0.9999\n",
    "    init_weight = min_weight  # 1.0/len(normalized_df.columns) # initialize to min to make the sliders easier to use.\n",
    "    weights = pd.Series(init_weight, index=normalized_df.columns, name=\"Weight\")  # the current weight list\n",
    "    df_2D = dimension_reduction(normalized_df, weights)   # the current projected data\n",
    "#     plot_ax = create_plot(df_2D, imgDisplaySize)\n",
    "#     size_slider = create_size_slider(imgDisplaySize)\n",
    "#     sliders = create_sliders(weights)\n",
    "#     size_apply_button = create_size_slider_button(size_slider,plot_ax)\n",
    "\n",
    "#     inverse_button = create_inverse_button(plot_ax, size_slider, sliders)\n",
    "#     display(widgets.HBox([inverse_button, create_slider_buttons(sliders,size_slider, plot_ax)\n",
    "#                           ,create_reset_buttons(plot_ax, size_slider, sliders)]))\n",
    "#     display(widgets.HBox([size_slider,size_apply_button]))\n",
    "\n",
    "#     point_attribute = create_checkbox(size_slider, plot_ax)\n",
    "\n",
    "#     for slider in sliders:\n",
    "#         slider.style.handle_color = 'lightgreen'\n",
    "#         display(slider)\n",
    "except Exception:\n",
    "    pass\n",
    "\n",
    "# if uploader.value!={}:     \n",
    "#     input_file = list(uploader.value.values())[0]\n",
    "#     content = input_file['content']\n",
    "#     content = io.StringIO(content.decode('utf-8'))\n",
    "#     df = pd.read_csv(content)\n",
    "#     #df.rename(columns = {'Image_Label':'Name'}, inplace=True)\n",
    "#     df.set_index('Image_Label', inplace=True)\n",
    "\n",
    "#     label_names = df.index.tolist()\n",
    "#     image_paths = {}\n",
    "#     for name in label_names:\n",
    "#         image_paths[name] = df['Image_Link'][name]\n",
    "\n",
    "#     df = df.loc[:, ~df.columns.isin(['Image_Link','Species','User','Date','Time','Annotations','Hex_Color_Code'])]\n",
    "#     df_numeric = df.select_dtypes(include='number')  #'int32' or 'int64' or 'float32' or 'float64'\n",
    "#     df_numeric = df_numeric.loc[:, (df_numeric != df_numeric.iloc[0]).any()] \n",
    "#     df_category = df.select_dtypes(exclude='number') #'object'\n",
    "#     normalized_df = (df_numeric - df_numeric.mean()) / df_numeric.std()\n",
    "# else:\n",
    "#     print(\"Please upload one csv. file\")\n",
    "    \n",
    "    \n",
    "def distance_matrix_HD(dataHDw):  \n",
    "    \"\"\"\n",
    "    Compute the distance matrix for the weighted high-dimensional data using L1 distance function.\n",
    "    Input HD data should already be weighted.\n",
    "    \n",
    "    @parameters:\n",
    "        dataHDw[pd.df or np.array]: weighted high-dimensional data\n",
    "    @return[array]: distance matrix for input weighted high-dimensional data\n",
    "    \"\"\"\n",
    "    dist_matrix = sklearn.metrics.pairwise.manhattan_distances(dataHDw)\n",
    "    return dist_matrix\n",
    "\n",
    "def distance_matrix_2D(data2D): \n",
    "    \"\"\"\n",
    "    Compute the distance matrix for 2D projected data using L2 distance function.\n",
    "    \n",
    "    @parameters: \n",
    "        data2D[pd.df or np.array]: projected 2D data\n",
    "    @return[np.array]: distance matrix for 2D input data\n",
    "    \"\"\"\n",
    "    dist_matrix = sklearn.metrics.pairwise.euclidean_distances(data2D) \n",
    "    return dist_matrix\n",
    "\n",
    "\n",
    "def stress(distHD, dist2D): \n",
    "    \"\"\"\n",
    "    Calculate the MDS stress metric between HD and 2D distances.\n",
    "    @parameters: \n",
    "        distHD[np.array]: distance matrix for high-dimensional data\n",
    "        dist2D[np.array]: distance matrix for 2D data\n",
    "    @return[float]: stress value\n",
    "    \"\"\"\n",
    "    s = ((distHD-dist2D)**2).sum() / (distHD**2).sum()   # numpy, eliminate sqrt for efficiency\n",
    "    return s\n",
    "\n",
    "def compute_mds(dataHDw):  \n",
    "    \"\"\"\n",
    "    apply MDS to high-dimensional data to get 2D data\n",
    "    @parameters:\n",
    "        dataHDw[pd.df or np.array]: weighted high-dimensional data\n",
    "    @return[dataframe]: a dataframe of 2D data \n",
    "    \"\"\"\n",
    "    distHD = distance_matrix_HD(dataHDw)\n",
    "    ### Adjust these parameters for performance/accuracy tradeoff\n",
    "    mds = sklearn.manifold.MDS(n_components=2, dissimilarity='precomputed', n_init=10, max_iter=1000, random_state=3)\n",
    "    # Reduction algorithm happens here:  data2D is n*2 matrix\n",
    "    data2D = mds.fit_transform(distHD)\n",
    "    \n",
    "    ### Rotate the resulting 2D projection to make it more consistent across multiple runs.\n",
    "    ### Set the 1st PC to the y axis, plot looks better to spread data vertically with horizontal text labels\n",
    "    pca = sklearn.decomposition.PCA(n_components=2)\n",
    "    data2D = pca.fit_transform(data2D)\n",
    "    data2D = pd.DataFrame(data2D, columns=['y','x'], index=dataHDw.index)\n",
    "    \n",
    "    data2D.stress_value = stress(distHD, distance_matrix_2D(data2D))\n",
    "    return data2D\n",
    "\n",
    "def dimension_reduction(dataHD, wts): # dataHD, wts -> data2D (pandas)\n",
    "    \"\"\"\n",
    "    apply weights to high-dimensional data then apply MDS to get 2D data\n",
    "    @parameters:\n",
    "        dataHD[pd.df or np.array]: original high-dimensional data\n",
    "    @return[dataframe]: a dataframe of projected 2D data\n",
    "    \"\"\"\n",
    "    ### Normalize the weights to sum to 1\n",
    "    wts = wts/wts.sum()\n",
    "    \n",
    "    ### Apply weights to the HD data \n",
    "    dataHDw = dataHD * wts\n",
    "    \n",
    "    ### DR algorithm\n",
    "    data2D = compute_mds(dataHDw)\n",
    "\n",
    "    ### Compute row relevances as:  data dot weights\n",
    "    ### High relevance means large values in upweighted dimensions\n",
    "#     data2D['relevance'] = dataHDw.sum(axis=1)\n",
    "    return data2D\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def new_proposal(current, step, direction):\n",
    "    return np.clip(current + direction*step*random.random(), 0.00001, 0.9999)\n",
    "\n",
    "def inverse_DR(dataHD, data2D, curWeights=None): \n",
    "    \"\"\"\n",
    "    @parameters:\n",
    "        dataHD[pd.df or np.array]: high-dimensional data\n",
    "        data2D[pd.df or np.array]: projected 2D data\n",
    "    @return[pd.Series]: new weights  \n",
    "    \"\"\"\n",
    "    dist2D = distance_matrix_2D(data2D)  # compute 2D distances only once\n",
    "    col_names = dataHD.columns\n",
    "    dataHD = dataHD.to_numpy()  # use numpy for efficiency\n",
    "    row, col = dataHD.shape\n",
    "    \n",
    "    if curWeights==None:\n",
    "        curWeights = np.array([1.0/col]*col)  # default weights = 1/p\n",
    "    else:\n",
    "        curWeights = curWeights.to_numpy()\n",
    "        curWeights = curWeights / curWeights.sum()  # Normalize weights to sum to 1\n",
    "    newWeights = curWeights.copy()  # re-use this array for efficiency\n",
    "    \n",
    "    # Initialize state\n",
    "    flag = [0]*col         # degree of success of a weight change\n",
    "    direction = [1]*col  # direction to move a weight, pos or neg\n",
    "    step = [1.0/col]*col   # how much to change each weight\n",
    "    \n",
    "    dataHDw = dataHD * curWeights   # weighted space, re-use this array for efficiency\n",
    "    distHD = distance_matrix_HD(dataHDw)\n",
    "    curStress = stress(distHD, dist2D)\n",
    "    print('Starting stress =', curStress, 'Processing...')\n",
    "\n",
    "    MAX = 500   # default setting of the number of iterations\n",
    "\n",
    "    # Try to minorly adjust each weight to see if it reduces stress\n",
    "    for i in range(MAX):\n",
    "        for dim in range(col):            \n",
    "            # Get a new weight for current column\n",
    "            nw = new_proposal(curWeights[dim], step[dim], direction[dim])\n",
    "            \n",
    "            # Scale the weight list such that it sums to 1\n",
    "            s = 1.0  + nw - curWeights[dim]   # 1.0 == curWeights.sum()\n",
    "            np.true_divide(curWeights, s, out=newWeights)  # transfers to other array, while doing /\n",
    "            newWeights[dim] = nw / s\n",
    "            \n",
    "            # Apply new weights to HD data\n",
    "            np.multiply(dataHD, newWeights, out=dataHDw)  # dataHDw = dataHD * newWeights; efficiently reuses dataHDw array\n",
    "            distHD = distance_matrix_HD(dataHDw)\n",
    "\n",
    "            # Get the new stress\n",
    "            newStress = stress(distHD, dist2D)\n",
    "            \n",
    "            # If new stress is lower, then update weights and flag this success\n",
    "            if newStress < curStress:\n",
    "                temp = curWeights\n",
    "                curWeights = newWeights\n",
    "                newWeights = temp   # reuse the old array next iteration\n",
    "                curStress = newStress\n",
    "                flag[dim] = flag[dim] + 1\n",
    "            else:\n",
    "                flag[dim] = flag[dim] - 1\n",
    "                direction[dim] = -direction[dim]  # Reverse course\n",
    "    \n",
    "            # If recent success, then speed up the step rate\n",
    "            if flag[dim] >= 5:\n",
    "                step[dim] = step[dim] * 2\n",
    "                flag[dim] = 0\n",
    "            elif flag[dim] <= -5:\n",
    "                step[dim] = step[dim] / 2\n",
    "                flag[dim] = 0\n",
    "                \n",
    "    print('Solution stress =', curStress, 'Done.')\n",
    "    return pd.Series(curWeights, index=col_names, name=\"Weight\")\n",
    "\n",
    "def create_size_slider(imgDisplaySize):\n",
    "    \"\"\"\n",
    "    Create image size adjust slider\n",
    "    @parameters:\n",
    "        imgDisplaySize[float]: zoom image displayed size\n",
    "    @return[widgets slider]: return the slize adjustment slider \n",
    "    \"\"\"\n",
    "\n",
    "    style = {'description_width': 'initial'}\n",
    "    size_slider = widgets.FloatSlider(min=0, max=1, step=0.01, value=imgDisplaySize, \n",
    "                                       description='Adjust image size', style = style, \n",
    "                                   continuous_update=False, readout_format='.5f',)\n",
    "    size_slider.style.handle_color = 'lightblue'\n",
    "    return size_slider\n",
    "\n",
    "# sliders for weights\n",
    "def create_sliders(wts):\n",
    "    # Create sliders, one for each dimension weight\n",
    "    sliders = [widgets.FloatSlider(min=min_weight, max=max_weight, step=0.01, value=value, \n",
    "                                       description=label, continuous_update=False,\n",
    "                                   layout=Layout(width='80%', height='20px'),readout_format='.5f')\n",
    "                   for (label, value) in wts.iteritems()]\n",
    "#     for slider in sliders:\n",
    "#         slider.style.handle_color = 'lightgreen'\n",
    "#         display(slider)\n",
    "        \n",
    "    return sliders \n",
    "\n",
    "# checkboxes\n",
    "def create_checkbox(size_slider, ax):\n",
    "    \"\"\"\n",
    "    @return: create the checkbox to toggle the images and titles(image index in the dataframe)  \n",
    "    \"\"\"\n",
    "    title_checkbox = widgets.Checkbox(False, description='Toggle Titles',indent=False,\n",
    "                                      layout=Layout(width='20%', height='20px'))\n",
    "    image_checkbox = widgets.Checkbox(True, description='Toggle Images',indent=False,\n",
    "                                      layout=Layout(width='20%', height='20px'))\n",
    "    \n",
    "    def title_check_clicked(x):   \n",
    "        image = image_checkbox.value\n",
    "        draw_plot(ax, df_2D, size_slider.value, x, image)\n",
    "        ax.figure.canvas.draw()\n",
    "    interact(title_check_clicked, x=title_checkbox)\n",
    "    \n",
    "    def image_clicked(x):   \n",
    "        title = title_checkbox.value\n",
    "        draw_plot(ax, df_2D, size_slider.value, title, x)\n",
    "        ax.figure.canvas.draw()\n",
    "    interact(image_clicked, x=image_checkbox)\n",
    "    return title_checkbox, image_checkbox\n",
    "\n",
    "def create_size_slider_button(size_slider, ax): \n",
    "    \"\"\"\n",
    "    @parameters:\n",
    "        size_slider: \n",
    "        ax:\n",
    "    @return[button]: return image size adjust button\n",
    "    \"\"\"\n",
    "    size_apply_button = widgets.Button(description='Apply Slider Size',\n",
    "                                      style=ButtonStyle(button_color='lightblue'))\n",
    "    def size_slider_button_clicked(change):\n",
    "        toggle_image = hasattr(ax.dragpoint.artists[0], 'ab')\n",
    "        toggle_tittle = ax.dragpoint.artists[0].text.get_text() != ''\n",
    "        draw_plot(ax, df_2D, size_slider.value, toggle_tittle, toggle_image)\n",
    "        ax.figure.canvas.draw()\n",
    "    size_apply_button.on_click(size_slider_button_clicked)\n",
    "    return size_apply_button\n",
    "\n",
    "# apply slider weights\n",
    "def create_slider_buttons(sliders, size_slider, ax):    \n",
    "    apply_button = widgets.Button(description='Apply Slider Weights',style=ButtonStyle(button_color='lightgreen'),\n",
    "                                  layout=Layout(width='22.7%'))\n",
    "\n",
    "    # Callback functions\n",
    "    def apply_button_clicked(change):\n",
    "        # Use the slider values to recompute the DR and redraw the plot\n",
    "        global weights, df_2D, imageIndex_path_dict   # Update weights and df_2D globals\n",
    "        weights = pd.Series([s.value for s in sliders], index=normalized_df.columns, name='Weight')\n",
    "        df_2D = dimension_reduction(normalized_df, weights)   \n",
    "        \n",
    "        # Redraw the plot\n",
    "        toggle_image = hasattr(ax.dragpoint.artists[0], 'ab')\n",
    "        toggle_tittle = ax.dragpoint.artists[0].text.get_text() != ''\n",
    "        draw_plot(ax, df_2D, size_slider.value, toggle_tittle, toggle_image)\n",
    "        ax.figure.canvas.draw()\n",
    "    apply_button.on_click(apply_button_clicked)\n",
    "    \n",
    "\n",
    "    return apply_button\n",
    "\n",
    "def create_reset_buttons(ax, size_slider, sliders):\n",
    "    \"\"\"\n",
    "    @return[button]: return reset plot button  \n",
    "    \"\"\"  \n",
    "    reset_button = widgets.Button(description='Reset Plot',style=ButtonStyle(button_color='salmon'))\n",
    "    def reset_button_clicked(change):\n",
    "        for s in sliders:\n",
    "            s.value = init_weight            \n",
    "        global weights, df_2D, normalized_df   # Update weights and df_2D globals\n",
    "        weights = pd.Series(init_weight, index=normalized_df.columns, name=\"Weight\")\n",
    "        df_2D = dimension_reduction(normalized_df, weights)   \n",
    "        toggle_image = hasattr(ax.dragpoint.artists[0], 'ab')\n",
    "        toggle_tittle = ax.dragpoint.artists[0].text.get_text() != ''\n",
    "        # Redraw the plot\n",
    "        draw_plot(ax, df_2D, size_slider.value, toggle_tittle, toggle_image)\n",
    "        ax.figure.canvas.draw()\n",
    "    reset_button.on_click(reset_button_clicked)\n",
    "\n",
    "    return reset_button\n",
    "\n",
    "def create_inverse_button(ax, size_slider, sliders, fig_show=False):\n",
    "    \"\"\"\n",
    "    @return[button]: return 'Learn New Weights' and 'Update Projections' buttons\n",
    "    \"\"\"\n",
    "    inverse_button = widgets.Button(description='Apply Moved Observations',\n",
    "                                    style=ButtonStyle(button_color='darkseagreen'),layout=Layout(width='22.7%'))\n",
    "#     copy_button = widgets.Button(description='Update Projections',\n",
    "#                                  style=ButtonStyle(button_color='darkseagreen'))\n",
    "\n",
    "    def inverse_button_clicked(change):\n",
    "        # Check minimum number of points moved\n",
    "        n = sum([i.selected for i in ax.dragpoint.artists])\n",
    "        if n < 2:\n",
    "            print('Need to select or move at least 2 points in the plot first.')\n",
    "            return\n",
    "\n",
    "        # Get selected data points\n",
    "        data2Dnew = pd.DataFrame([c.center for c in ax.dragpoint.artists if c.selected], columns=['x','y'], \n",
    "                                    index=[c.label for c in ax.dragpoint.artists if c.selected]) \n",
    "        global normalized_df\n",
    "        dataHDpart = normalized_df.loc[data2Dnew.index]\n",
    "\n",
    "        # Learn new weights\n",
    "        global weights\n",
    "        weights = inverse_DR(dataHDpart, data2Dnew)\n",
    "        \n",
    "        for i,s in enumerate(sliders):\n",
    "            s.value = weights[i]\n",
    "\n",
    "    inverse_button.on_click(inverse_button_clicked)\n",
    "        \n",
    "    return inverse_button\n",
    "\n",
    "\n",
    "class DraggablePoints(object):\n",
    "    def __init__(self, ax, artists):\n",
    "        self.ax = ax\n",
    "        self.artists = artists\n",
    "        self.current_artist = None\n",
    "        self.last_selected = None\n",
    "        ax.selected_text.set_text('Selected: none')\n",
    "        self.offset = (0, 0)\n",
    "        # Set up mouse listeners\n",
    "        ax.figure.canvas.mpl_connect('pick_event', self.on_pick)\n",
    "        ax.figure.canvas.mpl_connect('motion_notify_event', self.on_motion)\n",
    "        ax.figure.canvas.mpl_connect('button_release_event', self.on_release)\n",
    "\n",
    "    def on_pick(self, event):\n",
    "        # When point is clicked on (mouse down), select it and start the drag\n",
    "        if self.current_artist is None:  # clicking on overlapped points sends multiple events\n",
    "            self.last_selected = event.artist.index  # event.ind\n",
    "            self.current_artist = event.artist\n",
    "            event.artist.selected = True\n",
    "            event.artist.savecolor = event.artist.get_facecolor()\n",
    "            event.artist.set_facecolor('green')\n",
    "            #event.artist.set_alpha(1.0)\n",
    "            self.ax.selected_text.set_text(\"Selected: \" + event.artist.label)\n",
    "            x0, y0 = event.artist.center\n",
    "            self.offset = (x0 - event.mouseevent.xdata), (y0 - event.mouseevent.ydata)\n",
    "\n",
    "    def on_motion(self, event):\n",
    "        # When dragging, check if point is selected and valid mouse coordinates\n",
    "        if (self.current_artist is not None) and (event.xdata is not None) and (event.ydata is not None):\n",
    "            # Drag the point and its text label\n",
    "            dx, dy = self.offset\n",
    "            self.current_artist.center = x0, y0 = event.xdata + dx, event.ydata + dy\n",
    "            self.current_artist.text.set_position((x0 + self.current_artist.radius, \n",
    "                                                   y0 ))\n",
    "            if self.current_artist.ab:\n",
    "                self.current_artist.ab.xybox = (x0,y0)\n",
    "        \n",
    "    def on_release(self, event):\n",
    "        # When mouse is released, stop the drag\n",
    "        self.ax.figure.canvas.draw()\n",
    "        self.current_artist = None\n",
    "        \n",
    "\n",
    "def create_plot(data2D, imgDisplaySize, title=False): \n",
    "    \"\"\"\n",
    "    @parameters:\n",
    "        data2D[pd.df or np.array]: projected 2D data\n",
    "        title[boolean]: toggle tittle or not \n",
    "    @return[AxesSubplot]: plotting axes\n",
    "    \"\"\"\n",
    "    # Initialize DR plot figure   \n",
    "    fig, ax = plt.subplots(figsize= (6,6), dpi=80)\n",
    "    ax.selected_text = ax.figure.text(0,0.005, 'Selected: none', wrap=True, color='green')\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.figure.tight_layout()\n",
    "#     global imageIndex_path_dict\n",
    "    \n",
    "    # Store state data:\n",
    "    ax.dragpoint = None\n",
    "    draw_plot(ax, data2D, imgDisplaySize, title)\n",
    "        \n",
    "    return ax\n",
    "\n",
    "def url_to_image(url):\n",
    "    # download the image, convert it to a NumPy array, and then read\n",
    "    # it into OpenCV format\n",
    "    resp = urllib.request.urlopen(url)\n",
    "    image = np.asarray(bytearray(resp.read()), dtype=\"uint8\")\n",
    "    image = cv2.imdecode(image, cv2.IMREAD_COLOR)\n",
    "    # return the image\n",
    "    return image\n",
    "\n",
    "def image_preprocessing(imgIndex):\n",
    "    \"\"\"\n",
    "    segment images if background is black\n",
    "    @parameters:\n",
    "        imgIndex[str]: image index\n",
    "    @return[np.array(image)]: processed image\n",
    "    \"\"\"\n",
    "\n",
    "    global image_paths\n",
    "    path = image_paths[imgIndex]\n",
    "    up_width = 150\n",
    "    up_height = 150\n",
    "    up_points = (up_width, up_height)    \n",
    "    src = url_to_image(path)\n",
    "    src = cv2.resize(src, up_points, interpolation= cv2.INTER_LINEAR)\n",
    "    tmp = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)        \n",
    "    _,alpha = cv2.threshold(tmp,0,255,cv2.THRESH_BINARY)\n",
    "    b, g, r = cv2.split(src)\n",
    "    rgba = [r,g,b, alpha]\n",
    "    processed_img = cv2.merge(rgba,4)\n",
    "\n",
    "    return processed_img\n",
    "\n",
    "def draw_plot(ax, data2D, imgSize, title=False, image=True): \n",
    "    \"\"\"\n",
    "    @parameters:\n",
    "        ax[AxesSubplot]: plot ax\n",
    "        data2D[dataframe]: projected 2D dataframe\n",
    "        title[boolean]: whether toggle title or not\n",
    "        image[boolean]: whether toggle image or not\n",
    "        imgSize[float]: zoom parameter of OffsetImage, determine size of displaying images\n",
    "    \"\"\"\n",
    "    labels_df = data2D.index.to_series().apply(lambda x: x.split('/')[0])\n",
    "    data2D['label'] = labels_df\n",
    "    label_list = list(set(data2D['label']))\n",
    "    conversion_dict = {k:v for k,v in zip(label_list,range(len(label_list)))}\n",
    "    data2D['label_num'] = data2D['label'].replace(conversion_dict)\n",
    "    ax.clear()\n",
    "    wid = max(data2D.x.max() - data2D.x.min(), data2D.y.max() - data2D.y.min()) # max range of x,y axes\n",
    "    if not image:\n",
    "        cnorm = mpl.colors.Normalize(vmin=data2D.label_num.min(), vmax=data2D.label_num.max())\n",
    "        \n",
    "        ax.circles = data2D.apply(axis=1, func=lambda row: \n",
    "            mpl.patches.Circle(xy=(row.x, row.y), radius=wid/70, alpha=0.95, label=row.label_num,\n",
    "                                       color = plt.cm.Set3(cnorm(row.label_num)),picker=True))\n",
    "        for i,c in enumerate(ax.circles):\n",
    "            # Store state data:\n",
    "            c.index, c.label, c.selected = i, data2D.index[i], False\n",
    "            # Draw circles and text labels in plot\n",
    "            ax.add_patch(c)\n",
    "            if title:\n",
    "                c.text = ax.text(c.center[0]+c.radius, c.center[1], c.label, color='black')\n",
    "            else:\n",
    "                c.text = ax.text(c.center[0]+c.radius, c.center[1], \"\", color='none')\n",
    "    else:\n",
    "        ax.circles = []\n",
    "        for x0, y0, index in zip(data2D.x, data2D.y, data2D.index):\n",
    "            ax.circles.append(mpl.patches.Circle(xy=(x0, y0), radius=wid*imgSize/3, alpha=0.5, \n",
    "                                       color = 'none',picker=True))\n",
    "\n",
    "        for i,c in enumerate(ax.circles):\n",
    "            # Store state data:\n",
    "            c.index, c.label, c.selected = i, data2D.index[i], False\n",
    "            # Draw circles and text labels in plot\n",
    "            ax.add_patch(c)\n",
    "            processed_img = image_preprocessing(c.label)\n",
    "            img = OffsetImage(processed_img,zoom=imgSize)\n",
    "            c.ab = AnnotationBbox(img, (c.center[0], c.center[1]), frameon=False)\n",
    "            ax.add_artist(c.ab)\n",
    "            if title:\n",
    "                c.text = ax.text(c.center[0]+c.radius, c.center[1], c.label, color='black')\n",
    "            else:\n",
    "                c.text = ax.text(c.center[0]+c.radius, c.center[1], \"\", color='none')\n",
    "\n",
    "    # Make plot circles draggable\n",
    "    ax.dragpoint = DraggablePoints(ax, ax.circles)\n",
    "    # Clean up the plot \n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.axis('equal')\n",
    "    \n",
    "imgDisplaySize =0.30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\n",
       "window.mpl = {};\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(\n",
       "            '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",
       "\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 = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(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 (fig.ratio !== 1) {\n",
       "            fig.send_message('set_device_pixel_ratio', {\n",
       "                device_pixel_ratio: fig.ratio,\n",
       "            });\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 = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
       "    if (this.ResizeObserver === undefined) {\n",
       "        if (window.ResizeObserver !== undefined) {\n",
       "            this.ResizeObserver = window.ResizeObserver;\n",
       "        } else {\n",
       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
       "            this.ResizeObserver = obs.ResizeObserver;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * fig.ratio);\n",
       "                canvas.setAttribute('height', height * fig.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    this.resizeObserverInstance.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'dblclick',\n",
       "        on_mouse_event_closure('dblclick')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\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 toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\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",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\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",
       "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",
       "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], msg['forward']);\n",
       "        fig.send_message('refresh', {});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
       "    var x0 = msg['x0'] / fig.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
       "    var x1 = msg['x1'] / fig.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / fig.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,\n",
       "        0,\n",
       "        fig.canvas.width / fig.ratio,\n",
       "        fig.canvas.height / fig.ratio\n",
       "    );\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",
       "    fig.rubberband_canvas.style.cursor = msg['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.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\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",
       "            var img = evt.data;\n",
       "            if (img.type !== 'image/png') {\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",
       "                img.type = 'image/png';\n",
       "            }\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",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                img\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\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(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\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(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "};\n",
       "\n",
       "// from https://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",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\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",
       " * https://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",
       "        }\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",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\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",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.key === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.key;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.key !== 'Control') {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    else if (event.altKey && event.key !== 'Alt') {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    else if (event.shiftKey && event.key !== 'Shift') {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k' + event.key;\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, 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",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\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\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "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.binaryType = comm.kernel.ws.binaryType;\n",
       "    ws.readyState = comm.kernel.ws.readyState;\n",
       "    function updateReadyState(_event) {\n",
       "        if (comm.kernel.ws) {\n",
       "            ws.readyState = comm.kernel.ws.readyState;\n",
       "        } else {\n",
       "            ws.readyState = 3; // Closed state.\n",
       "        }\n",
       "    }\n",
       "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
       "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
       "    comm.kernel.ws.addEventListener('error', updateReadyState);\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",
       "        var data = msg['content']['data'];\n",
       "        if (data['blob'] !== undefined) {\n",
       "            data = {\n",
       "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
       "            };\n",
       "        }\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(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 = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\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;\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",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\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.innerHTML =\n",
       "        '<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 / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<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 () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\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",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('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",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\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(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"480\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if 'df_2D' in locals():\n",
    "    plot_ax = create_plot(df_2D, imgDisplaySize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "98dde70c2a1f4c70949b45300c4c2d16",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Button(description='Apply Moved Observations', layout=Layout(width='22.7%'), style=ButtonStyle(…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "66d9c10608014dff893568f5c99defd4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatSlider(value=0.3, continuous_update=False, description='Adjust image size', max=1.0, reado…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed0cc897e6fd4bc8ba5f9be709eff8be",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Checkbox(value=False, description='Toggle Titles', indent=False, layout=Layout(height='2…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d43ad3fbed844b8b9648ad980e720703",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Checkbox(value=True, description='Toggle Images', indent=False, layout=Layout(height='20…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a199451f69b64be88429187ac63e5fcf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Seconds', layout=Layout(height='20px', width='8…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "662dc8a6f686442aa5ff41687b8fba1d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Lat', layout=Layout(height='20px', width='80%')…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0ad3fa976453485a8cdeb557e8cc2f09",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Long', layout=Layout(height='20px', width='80%'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "63f706b7b7fa41599cf698f38fd0ea5d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='R1', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a8fbd19fa78f44acac3dc74489557aca",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='G1', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "0338125ab2e64ab48bcd44497046db4d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='B1', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "80f439a67bfe451894b65e15906e0fb4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='R2', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "954c1427ce674a258a5a7bf7bbfddc67",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='G2', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "594ba4c930ae4679b2b35ec4b5519639",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='B2', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "690fd35b48e34440843c91806fcbc276",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='R3', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "435626739ffd45a1a1837973c22ce90c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='G3', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "873a374e330b4dea9dbe7f856c3ae110",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='B3', layout=Layout(height='20px', width='80%'),…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "56c3127d4512483da37c0b31a97d62b2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Per1', layout=Layout(height='20px', width='80%'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "71718e0833164d8ca681bfc896ac749b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Per2', layout=Layout(height='20px', width='80%'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b9ed8f944d4a4d81a21ffaa109a3e889",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Per3', layout=Layout(height='20px', width='80%'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ae03194966914fe5903112989baf29f8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Contour_Area', layout=Layout(height='20px', wid…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "72ea47e1c5954e958d4453163a76c710",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Width', layout=Layout(height='20px', width='80%…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "cda5384618f840c7957cfcecb136e0e5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Height', layout=Layout(height='20px', width='80…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "97d5d77a76fd4b6d8b099b55fa8de0b1",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Aspect_Ratio', layout=Layout(height='20px', wid…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "38d9ace1f6774ff19f31952ad7ccd9c8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Extent', layout=Layout(height='20px', width='80…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "760aad9927b643dfb963ece9c5eebe56",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "FloatSlider(value=1e-05, continuous_update=False, description='Solidity', layout=Layout(height='20px', width='…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if 'df_2D' in locals():\n",
    "    size_slider = create_size_slider(imgDisplaySize)\n",
    "    sliders = create_sliders(weights)\n",
    "    size_apply_button = create_size_slider_button(size_slider,plot_ax)\n",
    "\n",
    "    inverse_button = create_inverse_button(plot_ax, size_slider, sliders)\n",
    "    display(widgets.HBox([inverse_button, create_slider_buttons(sliders,size_slider, plot_ax)\n",
    "                          ,create_reset_buttons(plot_ax, size_slider, sliders)]))\n",
    "    display(widgets.HBox([size_slider,size_apply_button]))\n",
    "\n",
    "    point_attribute = create_checkbox(size_slider, plot_ax)\n",
    "\n",
    "    for slider in sliders:\n",
    "        slider.style.handle_color = 'lightgreen'\n",
    "        display(slider)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}