aplicacion.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><center>Laboratory Electronic Notebook</center></h1>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:100% !important; }/*This file contains any manual css for this page that needs to override the global styles. This is only required when different pages style the same element differently. This is just a hack to deal with our current css styles and no new styling should be added in this file.*/  #ipython-main-app {     position: relative; } #jupyter-main-app {     position: relative; }   /*Hemendik aurrera nik idatzi det*/ body {    font-family: Ubuntu, sans-serif; }  .jupyter-widgets { \tmargin: 5px !important; \tfont-family: Ubuntu, sans-serif !important; }  .jupyter-button { \ttop: 4px !important; \tline-height: 28px !important; }  .widget-text { \tfont-size: 15px !important; }  .output_subarea { \tmargin: auto; }  /*formularioen stylea*/ /* naranja: #fcba05 */ /* gris: #afafaf */  input[type=text] { \tpadding: 3px !important; \tborder: 0 0 0 0; \tborder-bottom-color: #fcba05 !important; \tborder-bottom-width: 2px !important; \t \tborder-top-width: 1px !important; \tborder-left-width: 1px !important; \tborder-right-width: 1px !important; \t \tborder-top-color: transparent !important; \tborder-left-color: transparent !important; \tborder-right-color: transparent !important; }  input[type=text]:hover{ \t     border-top-color: #afafaf !important; \tborder-left-color: #afafaf !important; \tborder-right-color: #afafaf !important; }  input[type=text]:focus{     border-top-color: #fcba05 !important; \tborder-left-color: #fcba05 !important; \tborder-right-color: #fcba05 !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>.container { width:100% !important; }/*This file contains any manual css for this page that needs to override the global styles. This is only required when different pages style the same element differently. This is just a hack to deal with our current css styles and no new styling should be added in this file.*/  #ipython-main-app {     position: relative; } #jupyter-main-app {     position: relative; }   /*Hemendik aurrera nik idatzi det*/ body {    font-family: Ubuntu, sans-serif; }  .jupyter-widgets { \tmargin: 5px !important; \tfont-family: Ubuntu, sans-serif !important; }  .jupyter-button { \ttop: 4px !important; \tline-height: 28px !important; }  .widget-text { \tfont-size: 15px !important; }  .output_subarea { \tmargin: auto; }  /*formularioen stylea*/ /* naranja: #fcba05 */ /* gris: #afafaf */  input[type=text] { \tpadding: 3px !important; \tborder: 0 0 0 0; \tborder-bottom-color: #fcba05 !important; \tborder-bottom-width: 2px !important; \t \tborder-top-width: 1px !important; \tborder-left-width: 1px !important; \tborder-right-width: 1px !important; \t \tborder-top-color: transparent !important; \tborder-left-color: transparent !important; \tborder-right-color: transparent !important; }  input[type=text]:hover{ \t     border-top-color: #afafaf !important; \tborder-left-color: #afafaf !important; \tborder-right-color: #afafaf !important; }  input[type=text]:focus{     border-top-color: #fcba05 !important; \tborder-left-color: #fcba05 !important; \tborder-right-color: #fcba05 !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.jupyter-button{margin-top:5px} .widget-hbox{min-height:50px} .widget-checkbox .widget-label{width:0px} .widget-checkbox .widget-dropdown{width:0px}"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(HTML(\"<style>.jupyter-button{margin-top:5px} .widget-hbox{min-height:50px} .widget-checkbox .widget-label{width:0px} .widget-checkbox .widget-dropdown{width:0px}\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from bqplot import *\n",
    "import bqplot as bq\n",
    "import bqplot.marks as bqm\n",
    "import bqplot.scales as bqs\n",
    "import bqplot.axes as bqa\n",
    "\n",
    "from bqplot import pyplot as pyplot\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import pandas as pd\n",
    "\n",
    "from IPython.display import display, FileLink, FileLinks\n",
    "import ipywidgets as widgets\n",
    "\n",
    "import qgrid\n",
    "\n",
    "from traitlets import link\n",
    "\n",
    "import sys,os\n",
    "import csv\n",
    "\n",
    "import io\n",
    "import fileupload\n",
    "\n",
    "import matplotlib as mpl\n",
    "import matplotlib.colors as mcolors  \n",
    "import matplotlib.pyplot as plt      \n",
    "\n",
    "from matplotlib import rc            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def isNotNumber(s):\n",
    "    try:\n",
    "        float(s)\n",
    "    except:\n",
    "        return True\n",
    "    else:\n",
    "        return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class dataBase(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        dataBase.all = {}\n",
    "        dataBase.index = 0\n",
    "        \n",
    "    def addData(self, df, name=''):\n",
    "        \n",
    "        if name == '':\n",
    "            name = \"Data \" + str(self.getLastName())\n",
    "            self.incrementIndex()\n",
    "        elif name in self.all.keys():\n",
    "            name = name + \" \" + str(self.getLastName())\n",
    "            self.incrementIndex()\n",
    "\n",
    "        df = checkDFheader(df)\n",
    "        self.all[name] = df\n",
    "        refreshDataDropdown()\n",
    "        dataDropdown.value = name\n",
    "    \n",
    "    def updateData(self, df, name):\n",
    "        self.all[name] = df\n",
    "        \n",
    "    def getData(self, name):\n",
    "        if name not in self.all.keys():\n",
    "            return pd.DataFrame({\"x\": float(np.linspace(0.00, 0.00,1)), \"y\": np.linspace(0.00, 0.00,1)})\n",
    "        else:        \n",
    "            return self.all.get(name)\n",
    "    \n",
    "    def removeData(self, name):\n",
    "        if len(self.all) > 1:\n",
    "            del self.all[name]\n",
    "        \n",
    "    def getLastName(self):\n",
    "        return self.index\n",
    "    \n",
    "    def incrementIndex(self):\n",
    "        self.index = self.index + 1\n",
    "        \n",
    "    def show(self):\n",
    "        return self.all\n",
    "    \n",
    "    def getDatas(self):\n",
    "        return self.all.keys()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Checks if the dataframe has a non-numerical header\n",
    "def checkDFheader(df):\n",
    "    \n",
    "    header = list(df.columns)\n",
    "    noHeader = True\n",
    "    \n",
    "    for elem in header:\n",
    "        if isNotNumber(elem):\n",
    "            noHeader = False\n",
    "            break\n",
    "            \n",
    "    if noHeader:\n",
    "        df2 = pd.DataFrame()\n",
    "        for i in range(len(header)):\n",
    "            df2[str(i)] = np.append([float(header[i])], df[header[i]])\n",
    "        df = df2    \n",
    "        \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class plotBase(object):\n",
    "    \n",
    "    def __init__(self):\n",
    "        plotBase.all = {}\n",
    "        plotBase.plots = {}\n",
    "        plotBase.simulations = {}\n",
    "        plotBase.plotIndex = 0\n",
    "        plotBase.simIndex = 0\n",
    "        \n",
    "    def addPlot(self, figure, name=''):\n",
    "        if name == '':\n",
    "            name = \"Plot \" + str(plotBase.plotIndex)\n",
    "        elif name in plotBase.plots.keys():\n",
    "            name = name + \" \" + str(plotBase.plotIndex)\n",
    "\n",
    "\n",
    "        sc_x = figure.marks[3].scales.get('x')\n",
    "        sc_y = figure.marks[3].scales.get('y')\n",
    "\n",
    "        scale_x = bqm.LinearScale(min = sc_x.min, max = sc_x.max)\n",
    "        scale_y = bqm.LinearScale(min = sc_y.min, max = sc_y.max)\n",
    "        \n",
    "        ax = figure.axes[0]\n",
    "        ay = figure.axes[1]\n",
    "        \n",
    "        axis_x = bqa.Axis(scale=scale_x,\n",
    "                tick_format='0.2f',\n",
    "                tick_style= {'font-size': '15px'},\n",
    "                num_ticks = ax.num_ticks,\n",
    "                grid_lines = ax.grid_lines,\n",
    "                grid_color = '#8e8e8e', \n",
    "                label=ax.label,\n",
    "                label_location='middle',\n",
    "                label_offset='50px')\n",
    "        \n",
    "        axis_y = bqa.Axis(scale=scale_y,\n",
    "                tick_format='0.2f',\n",
    "                tick_style={'font-size': '15px'},\n",
    "                num_ticks = ay.num_ticks,\n",
    "                grid_lines = ay.grid_lines,\n",
    "                grid_color = '#8e8e8e', \n",
    "                label=ay.label,\n",
    "                orientation='vertical',\n",
    "                label_location='middle',\n",
    "                label_offset='50px')\n",
    "        \n",
    "        scatter = bqm.Scatter(x = figure.marks[3].x, \n",
    "                   y = figure.marks[3].y, \n",
    "                   scales = {'x': scale_x, 'y': scale_y}, \n",
    "                   enable_move = False,\n",
    "                   tooltip = tooltipScat,\n",
    "                   restrict_x = False,\n",
    "                   restrict_y = False,\n",
    "                   colors = figure.marks[3].colors,\n",
    "                   )\n",
    "        \n",
    "        distances = bqm.Lines(x = figure.marks[0].x,\n",
    "                 y = figure.marks[0].y,\n",
    "                 scales = {'x': scale_x, 'y': scale_y},\n",
    "                 line_style = 'dashed',\n",
    "                 visible = figure.marks[0].visible,\n",
    "                 colors = figure.marks[0].colors,\n",
    "                 )\n",
    "        \n",
    "        line = bqm.Lines(x = figure.marks[2].x, \n",
    "                y = figure.marks[2].y, \n",
    "                scales = {'x': scale_x, 'y': scale_y}, \n",
    "                visible = figure.marks[2].visible,\n",
    "                colors = figure.marks[2].colors,\n",
    "                )\n",
    "        \n",
    "        scatterEst = bqm.Scatter(x = figure.marks[1].x,\n",
    "                             y = figure.marks[1].y,\n",
    "                             scales = {'x': scale_x, 'y': scale_y},\n",
    "                             enable_move = False,\n",
    "                             visible = figure.marks[1].visible,\n",
    "                             colors = figure.marks[1].colors,\n",
    "                            )\n",
    "\n",
    "        fig = bq.Figure(title=figure.title,\n",
    "                marks=[distances, scatterEst, line, scatter],\n",
    "                axes=([axis_x, axis_y]),\n",
    "                animation_duration=500,\n",
    "                layout = widgets.Layout(width='90%', align_self='center'),\n",
    "                legend_location='top-right',\n",
    "                background_style= {'fill': 'white',  'stroke': 'black'},\n",
    "               )\n",
    "        \n",
    "        plotBase.all[name] = fig\n",
    "        plotBase.plots[name] = fig\n",
    "        \n",
    "        refreshPlotDropdown()\n",
    "        plotDropdown.value = name\n",
    "        plotBase.plotIndex = plotBase.plotIndex + 1\n",
    "        \n",
    "    def addSimulation(self, figure, name='', replace=False):\n",
    "        \n",
    "        if not replace:\n",
    "            if name == '':\n",
    "                name = \"Simulation \" + str(plotBase.simIndex)\n",
    "\n",
    "            elif name in plotBase.all.keys():\n",
    "                name = name + \" \" + str(plotBase.simIndex)\n",
    "\n",
    "        sc_x = figure.marks[3].scales.get('x')\n",
    "        sc_y = figure.marks[3].scales.get('y')\n",
    "\n",
    "        scale_x = bqm.LinearScale(min = sc_x.min, max = sc_x.max)\n",
    "        scale_y = bqm.LinearScale(min = sc_y.min, max = sc_y.max)\n",
    "            \n",
    "        ax = figure.axes[0]\n",
    "        ay = figure.axes[1]    \n",
    "            \n",
    "        axis_x = bqa.Axis(scale=scale_x,\n",
    "                tick_format='0.2f',\n",
    "                tick_style={'font-size': '15px'},\n",
    "                num_ticks = ax.num_ticks,\n",
    "                grid_lines = ax.grid_lines,\n",
    "                grid_color = '#8e8e8e', \n",
    "                label=ax.label,\n",
    "                label_location='middle',\n",
    "                label_offset='50px')\n",
    "        \n",
    "        axis_y = bqa.Axis(scale=scale_y,\n",
    "                tick_format='0.2f',\n",
    "                tick_style={'font-size': '15px'},\n",
    "                num_ticks = ay.num_ticks,\n",
    "                grid_lines = ay.grid_lines,\n",
    "                grid_color = '#8e8e8e', \n",
    "                label=ay.label,\n",
    "                orientation='vertical',\n",
    "                label_location='middle',\n",
    "                label_offset='50px')\n",
    "        \n",
    "        scatter = bqm.Scatter(x = figure.marks[3].x, \n",
    "                   y = figure.marks[3].y, \n",
    "                   scales = {'x': scale_x, 'y': scale_y}, \n",
    "                   enable_move = False,\n",
    "                   tooltip = tooltipScat,\n",
    "                   restrict_x = False,\n",
    "                   restrict_y = False,\n",
    "                   colors = figure.marks[3].colors,\n",
    "                   )\n",
    "        \n",
    "        distances = bqm.Lines(x = figure.marks[0].x,\n",
    "                 y = figure.marks[0].y,\n",
    "                 scales = {'x': scale_x, 'y': scale_y},\n",
    "                 line_style = 'dashed',\n",
    "                 visible = figure.marks[0].visible,\n",
    "                 colors = figure.marks[0].colors,\n",
    "                 )\n",
    "        \n",
    "        line = bqm.Lines(x = figure.marks[2].x, \n",
    "                y = figure.marks[2].y, \n",
    "                scales = {'x': scale_x, 'y': scale_y}, \n",
    "                visible = figure.marks[2].visible,\n",
    "                colors = figure.marks[2].colors,\n",
    "                )\n",
    "        \n",
    "        scatterEst = bqm.Scatter(x = figure.marks[1].x,\n",
    "                             y = figure.marks[1].y,\n",
    "                             scales = {'x': scale_x, 'y': scale_y},\n",
    "                             enable_move = False,\n",
    "                             visible = figure.marks[1].visible,\n",
    "                             colors = figure.marks[1].colors,\n",
    "                            )\n",
    "\n",
    "        fig = bq.Figure(title=figure.title,\n",
    "                marks=[distances, scatterEst, line, scatter],\n",
    "                axes=([axis_x, axis_y]),\n",
    "                animation_duration=500,\n",
    "                layout = widgets.Layout(width='90%', align_self='center'),\n",
    "                legend_location='top-right',\n",
    "                background_style= {'fill': 'white',  'stroke': 'black'},\n",
    "               )\n",
    "            \n",
    "        plotBase.all[name] = fig\n",
    "        plotBase.simulations[name] = fig\n",
    "        \n",
    "        refreshSimDropdown()\n",
    "\n",
    "        simDropdown.value = name\n",
    "        plotBase.simIndex = plotBase.simIndex + 1\n",
    "        \n",
    "    def getPlot(self, name):\n",
    "        return plotBase.all.get(name)\n",
    "    \n",
    "    def removePlot(self, name):\n",
    "        if len(self.plots) > 1:\n",
    "            del self.all[name]\n",
    "            del  self.plots[name]\n",
    "\n",
    "    def removeSimulation(self, name):\n",
    "        if len(self.simulations) > 1:\n",
    "            del self.all[name]\n",
    "            del  self.simulations[name]        \n",
    "            \n",
    "    def show(self):\n",
    "        return plotBase.all\n",
    "    \n",
    "    def getPlots(self):\n",
    "        return [elem for elem in plotBase.plots.keys()]\n",
    "    \n",
    "    def getSimulations(self):\n",
    "        return [elem for elem in plotBase.simulations.keys()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "db = dataBase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "pb = plotBase()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "fb = { '-Select file-': ''}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "mainBlock = widgets.VBox([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "topBlock = widgets.VBox([], layout = widgets.Layout(border='solid 1px', padding='20px'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "header = widgets.HTML(\n",
    "    value = \"<h1>Start working: open your data</h1> <hr>\"    \n",
    ")\n",
    "\n",
    "topBlock.children = [header,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "style_1 = {\n",
    "    'description_width': 'initial',\n",
    "          }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "spacerText = widgets.HTML(\n",
    "    value = \"<br>\"    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uploadFile():\n",
    "    \"\"\"Create an upload files button that prints the file name and file size.\n",
    "    \"\"\"\n",
    "\n",
    "    _upload_widget = fileupload.FileUploadWidget()\n",
    "\n",
    "    def _cb(change):\n",
    "        decoded = io.StringIO(change['owner'].data.decode('utf-8'))\n",
    "        filename = change['owner'].filename\n",
    "\n",
    "    _upload_widget.observe(_cb, names='data')\n",
    "    return _upload_widget\n",
    "\n",
    "uploadButton = uploadFile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "uploadBlock = widgets.VBox([])\n",
    "\n",
    "uploadText = widgets.HTML(\n",
    "    value = \"<h2>Open your CSV file from your computer:</h2> <hr>\"    \n",
    ")\n",
    "\n",
    "uploadDataName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type your data's name (optional):\",\n",
    "    description=\"<h4>Name: </h4>\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "uploadedText = widgets.HTML(\n",
    "    value = \"\",\n",
    ")\n",
    "\n",
    "uploadBlock.children = [uploadText, widgets.HBox([uploadDataName,uploadButton]), uploadedText]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "topBlock.children = topBlock.children+(uploadBlock,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uploadCSV(change):\n",
    "    \n",
    "    try:\n",
    "        uploadedText.value = \"<b>Uploading file...</b>\"\n",
    "        datastr = str(uploadButton.data,'utf-8')\n",
    "        datatbl = io.StringIO(datastr)\n",
    "        dfNew = pd.read_csv(datatbl)\n",
    "        db.addData(dfNew, uploadDataName.value)\n",
    "        uploadedText.value = \"<span style='color:green'><b>'\"+ uploadButton.filename + \"' file successfully loaded</b></span>\"\n",
    "        header.layout = {'display' : 'none'}\n",
    "        refreshDataDropdown()\n",
    "        if len(dataDropdown.options) > 0:\n",
    "            bodyBlock.children = [chartBlock, plotBlock]\n",
    "        mainBlock.children = [topBlock, bodyBlock, bottomBlock]\n",
    "        liveUpdateCheckbox.value = False\n",
    "        uploadDataName.value = ''    \n",
    "        \n",
    "    except Exception as e:\n",
    "        uploadedText.value = \"<span style='color:red'><b>An error has occurred, choose another file</b></span>\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "uploadButton.observe(uploadCSV,'data')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "csvBlock = widgets.VBox([])\n",
    "\n",
    "csvBlock1 = widgets.HBox([])\n",
    "csvBlock2 = widgets.HBox([])\n",
    "\n",
    "csvText = widgets.HTML(\n",
    "    value = \"<h2>Open your CSV file from the server:</h2> <hr>\"    \n",
    ")\n",
    "\n",
    "dataName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type your data's name (optional):\",\n",
    "    description=\"<h4>Name: </h4>\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "\n",
    "\n",
    "csvBlock1.children = [\n",
    "    dataName]\n",
    "\n",
    "filesDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h4>Choose your file: </h4>',\n",
    "    style = style_1\n",
    ")\n",
    "\n",
    "\n",
    "filePath = widgets.Text(\n",
    "    value= '',\n",
    "    placeholder=\"Type your file's path:\",\n",
    "    description=\"<h4>Path: </h4>\",\n",
    "    disabled=False,\n",
    "    layout = {'width' : '80%'}\n",
    ")\n",
    "\n",
    "loadButton = widgets.ToggleButton(\n",
    "    description='Open file',\n",
    "    disabled=False,\n",
    "    button_style='', \n",
    "    style = {\n",
    "        'display': 'block',\n",
    "        'margin': '0px auto',\n",
    "        'height' : '28px',\n",
    "        'border-radius' : '25px'\n",
    "            }\n",
    ")\n",
    "\n",
    "loadedText = widgets.HTML(\n",
    "    value = \"\",\n",
    ")\n",
    "\n",
    "csvBlock2.children = [\n",
    "    filesDropdown,\n",
    "    filePath,\n",
    "    loadButton,\n",
    "]\n",
    "\n",
    "csvBlock.children = [\n",
    "    csvText,\n",
    "    csvBlock1,\n",
    "    csvBlock2,\n",
    "    loadedText\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "topBlock.children = topBlock.children+(csvBlock,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshDataDropdown():\n",
    "    dataDropdown.options = db.getDatas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshFilesDropdown():\n",
    "        \n",
    "    root = os.getcwd()  \n",
    "    for path, subdirs, files in os.walk(root):\n",
    "        for name in files:\n",
    "            if name[-4:] == '.csv':\n",
    "                p = os.path.join(path, name)\n",
    "                f = p.replace(root + os.sep, '')\n",
    "                fb[f] = p\n",
    "                \n",
    "    filesDropdown.options = sorted(fb.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "refreshFilesDropdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshPath(change):\n",
    "    filePath.value = fb.get(filesDropdown.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "filesDropdown.observe(refreshPath, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def openCSVFile(a):\n",
    "    if loadButton.value == True:\n",
    "        loadButton.value = False\n",
    "        path = filePath.value\n",
    "        if path == '':\n",
    "            return None\n",
    "        \n",
    "        p = path.split()\n",
    "        path = ''.join(p)\n",
    "        \n",
    "        try:\n",
    "    \n",
    "            data0 = pd.read_csv(str(path))       \n",
    "            db.addData(data0, dataName.value)\n",
    "            filePath.value = ''\n",
    "            loadedText.value = \"<span style='color:green'><b>File successfully loaded</b></span>\"\n",
    "            dataName.value = ''\n",
    "            header.layout = {'display' : 'none'}\n",
    "            refreshDataDropdown()\n",
    "            if len(dataDropdown.options) > 0:\n",
    "                bodyBlock.children = [chartBlock, plotBlock]\n",
    "            mainBlock.children = [topBlock, bodyBlock, bottomBlock]\n",
    "            liveUpdateCheckbox.value = False\n",
    "            filesDropdown.value = filesDropdown.options[0]\n",
    "\n",
    "        except:\n",
    "            \n",
    "            filePath.value = ''\n",
    "            filesDropdown.value = sorted(fb.keys())[0]\n",
    "            loadedText.value = \"<span style='color:red'><b>An error has occurred, insert your file's path</b></span>\"\n",
    "            filesDropdown.value = filesDropdown.options[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "loadButton.observe(openCSVFile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "blankChartText = widgets.HTML(\n",
    "    value = \"<h2>or create new blank chart:</h2> <hr>\"    \n",
    ")\n",
    "\n",
    "blankChartButton = widgets.ToggleButton(\n",
    "    description='New chart',\n",
    "    disabled=False,\n",
    "    button_style='warning', \n",
    ")\n",
    "\n",
    "dataBlankName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type your data's name (optional):\",\n",
    "    description=\"<h4>Name: </h4>\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "createdText = widgets.HTML(\n",
    "    value = \"\",\n",
    ")\n",
    "\n",
    "topBlock.children = topBlock.children + (blankChartText, widgets.HBox([dataBlankName, blankChartButton,]), createdText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def newBlankChart(change):\n",
    "    if blankChartButton.value:\n",
    "        blankChartButton.value = False\n",
    "        df = pd.DataFrame([np.array([0.0, 0.0])], columns=['A', 'B'])\n",
    "        db.addData(df, dataBlankName.value)\n",
    "        dataBlankName.value = ''\n",
    "        header.layout = {'display' : 'none'}\n",
    "        createdText.value = \"<span style='color:green'><b>Blank chart successfully created</b></span>.\"\n",
    "        if len(dataDropdown.options) == 1:\n",
    "            bodyBlock.children = [chartBlock, plotBlock]\n",
    "            mainBlock.children = mainBlock.children + (bottomBlock,)\n",
    "        liveUpdateCheckbox.value = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "blankChartButton.observe(newBlankChart, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "bodyBlock = widgets.HBox([])\n",
    "\n",
    "chartBlock = widgets.VBox([],layout=widgets.Layout(width='50%', border='solid 1px', padding='20px'))\n",
    "plotBlock = widgets.VBox([],layout=widgets.Layout(width='50%', border='solid 1px', padding='20px'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "mainBlock.children = [topBlock, bodyBlock]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h4>Choose your data: </h4>',\n",
    "    style = style_1\n",
    ")\n",
    "\n",
    "deleteDataButton = widgets.ToggleButton(\n",
    "    description = 'Delete data',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "chartBlock.children = chartBlock.children + (widgets.HBox([dataDropdown, deleteDataButton]), )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deleteData(change):\n",
    "    if deleteDataButton.value:\n",
    "        deleteDataButton.value = False\n",
    "        name = dataDropdown.value\n",
    "        index = 0\n",
    "        \n",
    "        for i in range(len(dataDropdown.options)):\n",
    "            opt = dataDropdown.options[i]\n",
    "            if opt == name:\n",
    "                index = i\n",
    "                break\n",
    "        \n",
    "        index = index - 1\n",
    "        \n",
    "        dataDropdown.value = dataDropdown.options[index]\n",
    "        db.removeData(name)\n",
    "        refreshDataDropdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "deleteDataButton.observe(deleteData, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "precisionDropdown = widgets.Dropdown(\n",
    "    options = [i for i in range(0, 15)],\n",
    "    value = 6,\n",
    "    description='<h4>Number of decimals: </h4>',\n",
    "    style = style_1\n",
    ")\n",
    "\n",
    "chartBlock.children = chartBlock.children + (precisionDropdown, spacerText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changePrecision(change):\n",
    "    qGridCurrent.df = qGridCurrent.get_changed_df()\n",
    "    qGridCurrent.precision = int(precisionDropdown.value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "precisionDropdown.observe(changePrecision, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "chart = widgets.VBox([])\n",
    "columnOptionsBox = widgets.VBox([])\n",
    "rowOptionsBox = widgets.VBox([])\n",
    "\n",
    "qGridCurrent = qgrid.QGridWidget(\n",
    "    df = db.getData(dataDropdown.value),\n",
    "    precision = 6,\n",
    "    editable = True\n",
    ")\n",
    "\n",
    "columnOptionsAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%')\n",
    ")\n",
    "\n",
    "rowOptionsAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshColumnDropdowns():\n",
    "    chooseColumnDropdown.options = qGridCurrent.df.columns.values\n",
    "    chooseRenameColumnDropdown.options = qGridCurrent.df.columns.values\n",
    "    finalColDropdown.options = qGridCurrent.df.columns.values\n",
    "    aColDropdown.options = qGridCurrent.df.columns.values\n",
    "    bColDropdown.options = qGridCurrent.df.columns.values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshChart(change):\n",
    "    \n",
    "    old = change.get('old')\n",
    "    new = change.get('new')\n",
    "\n",
    "    if old != new and old != None:\n",
    "        df = qGridCurrent.get_changed_df()\n",
    "        db.updateData(df, old)\n",
    "        \n",
    "    qGridCurrent.df = db.getData(new)\n",
    "    refreshColumnDropdowns()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataDropdown.observe(refreshChart, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "columnBox = widgets.VBox([])\n",
    "\n",
    "newColumnName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"New column's name:\",\n",
    "    description='',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "addColumnButton = widgets.ToggleButton(\n",
    "    description = 'Add column',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "chooseColumnDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h4>Choose a column: </h4>',\n",
    "    style = style_1\n",
    ")\n",
    "\n",
    "removeColumnButton = widgets.ToggleButton(\n",
    "    description = 'Remove column',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "renameColumnName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Column's new name:\",\n",
    "    description='',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "renameColumnButton = widgets.ToggleButton(\n",
    "    description = 'Rename column',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "chooseRenameColumnDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h4>Choose a column: </h4>',\n",
    "    style = style_1\n",
    ")\n",
    "\n",
    "columnBox.children = (widgets.HBox([\n",
    "                          newColumnName,\n",
    "                          addColumnButton]),\n",
    "                      widgets.HTML(value = \"<hr style = 'margin-top: 5px; margin-bottom: 0px;'>\"),\n",
    "                      widgets.HBox([\n",
    "                          chooseColumnDropdown,\n",
    "                          removeColumnButton]),\n",
    "                      widgets.HTML(value = \"<hr style = 'margin-top: 5px; margin-bottom: 0px;'>\"),\n",
    "                      chooseRenameColumnDropdown,\n",
    "                      widgets.HBox([\n",
    "                          renameColumnName,\n",
    "                          renameColumnButton]),\n",
    "                    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addColumn(change):\n",
    "    if addColumnButton.value:\n",
    "        addColumnButton.value = False\n",
    "        name = newColumnName.value\n",
    "        nameFound = False\n",
    "        if name == '' or name in qGridCurrent.df.columns.values:\n",
    "            alphabet0 = ['A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']\n",
    "            alphabet = [elem for elem in alphabet0]\n",
    "            counter = 0\n",
    "            while nameFound == False:\n",
    "                for elem in alphabet:\n",
    "                    if elem not in list(qGridCurrent.df.columns.values):\n",
    "                        name = elem\n",
    "                        nameFound = True\n",
    "                        break\n",
    "                alphabet = [alphabet0[counter]+alphabet[i] for i in range(len(alphabet0))]\n",
    "                counter = counter + 1\n",
    "                \n",
    "        qGridCurrent.df = qGridCurrent.get_changed_df()\n",
    "        qGridCurrent.df[name] = 0.0\n",
    "        qGridCurrent.df = qGridCurrent.df\n",
    "        \n",
    "        refreshColumnDropdowns()\n",
    "\n",
    "        refreshPlotterSelectors(change)\n",
    "        newColumnName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "addColumnButton.observe(addColumn, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def removeColumn(change):\n",
    "    if removeColumnButton.value:\n",
    "        removeColumnButton.value = False\n",
    "        qGridCurrent.df = qGridCurrent.get_changed_df()\n",
    "        qGridCurrent.df = qGridCurrent.df.drop(axis = 'columns', columns = chooseColumnDropdown.value)\n",
    "        \n",
    "        refreshColumnDropdowns()\n",
    "        \n",
    "        refreshPlotterSelectors(change)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "removeColumnButton.observe(removeColumn, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def renameColumn(change):\n",
    "    if renameColumnButton.value:\n",
    "        renameColumnButton.value = False\n",
    "        \n",
    "        if renameColumnName.value not in chooseRenameColumnDropdown.options and renameColumnName.value != '':\n",
    "            qGridCurrent.df = qGridCurrent.get_changed_df().rename(columns={ chooseRenameColumnDropdown.value : renameColumnName.value})\n",
    "            qGridCurrent.df = qGridCurrent.df\n",
    "\n",
    "            refreshColumnDropdowns()\n",
    "\n",
    "            refreshPlotterSelectors(change)\n",
    "            renameColumnName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "renameColumnButton.observe(renameColumn, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "rowBox = widgets.VBox([])\n",
    "\n",
    "addRowButton = widgets.ToggleButton(\n",
    "    description = 'Add row',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "removeRowButton = widgets.ToggleButton(\n",
    "    description = 'Remove row',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "rowBox.children = (widgets.HBox([\n",
    "                          addRowButton,\n",
    "                          removeRowButton], layout = widgets.Layout(align_self = 'center')),\n",
    "                    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addRow(change):\n",
    "    if addRowButton.value:\n",
    "        addRowButton.value = False\n",
    "        df = qGridCurrent.get_changed_df()\n",
    "        df.loc[len(df.index)] = [0.0 for i in range(len(df.columns))]\n",
    "        qGridCurrent.df = df\n",
    "        qGridCurrent.df = qGridCurrent.df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "addRowButton.observe(addRow, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def removeRow(change):\n",
    "    if removeRowButton.value:\n",
    "        removeRowButton.value = False\n",
    "        df = qGridCurrent.get_changed_df()\n",
    "        df = df.drop(axis = 'index', index=qGridCurrent.get_selected_rows())\n",
    "        qGridCurrent.df = df\n",
    "        qGridCurrent.df = qGridCurrent.df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "removeRowButton.observe(removeRow, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "exportAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%'),\n",
    "    title = 'Export your chart'\n",
    ")\n",
    "\n",
    "exportAccordion.set_title(0, 'Export your chart')\n",
    "\n",
    "exportBox = widgets.VBox([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "exportCSVBox = widgets.VBox()\n",
    "\n",
    "exportCSVButton = widgets.ToggleButton(\n",
    "    description = 'Export as CSV',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "exportCSVName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Save as (optional):\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "exportCSVText = widgets.HTML(\n",
    "    value = \"\",\n",
    ") \n",
    "\n",
    "exportCSVBox.children = (widgets.HBox([exportCSVName, exportCSVButton], layout = widgets.Layout(align_self = 'center')), exportCSVText)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exportCSV(change):\n",
    "    if exportCSVButton.value:\n",
    "        exportCSVButton.value = False\n",
    "        \n",
    "        try:\n",
    "            exportCSVText.value =\"<b>Creating CSV file...</b>\"\n",
    "            filename = exportCSVName.value\n",
    "            \n",
    "            if filename == '':\n",
    "                filename = dataDropdown.value.replace(' ', '_')\n",
    "                \n",
    "            if '.csv' not in filename:\n",
    "                filename = filename + '.csv'\n",
    "                \n",
    "            file = qGridCurrent.get_changed_df().to_csv(filename, index=False)\n",
    "            exportCSVText.value = \"<span style='color:green'><b>CSV file '\" + filename + \"' successfully created, download it here:</b></span><form action=\" + filename + \" target='_blank'><button type=''submit''>Download CSV</button></form>\"\n",
    "            exportCSVName.value = ''\n",
    "            refreshFilesDropdown()\n",
    "        except:\n",
    "            exportCSVText.value = \"<span style='color:red'><b>An error has occurred</b></span>\"\n",
    "            exportCSVName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "exportCSVButton.observe(exportCSV, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "exportTexBox = widgets.VBox()\n",
    "\n",
    "exportTexButton = widgets.ToggleButton(\n",
    "    description = 'Export as TEX',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "exportTexName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Save as (optional):\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "exportTexText = widgets.HTML(\n",
    "    value = \"\",\n",
    ") \n",
    "\n",
    "exportTexBox.children = (widgets.HBox([exportTexName, exportTexButton], layout = widgets.Layout(align_self = 'center')), exportTexText)\n",
    "\n",
    "exportAccordion.children = (exportBox,)\n",
    "exportBox.children = (exportCSVBox, exportTexBox)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exportTex(change):\n",
    "    if exportTexButton.value:\n",
    "        exportTexButton.value = False\n",
    "        \n",
    "        try:\n",
    "            exportTexText.value =\"<b>Creating TEX file...</b>\"\n",
    "            filename = exportTexName.value\n",
    "            \n",
    "            if filename == '':\n",
    "                filename = dataDropdown.value.replace(' ', '_')\n",
    "                \n",
    "            if '.tex' not in filename:\n",
    "                filename = filename + '.tex'\n",
    "                \n",
    "            file = qGridCurrent.get_changed_df().to_latex(filename, index=False)\n",
    "            exportTexText.value = \"<span style='color:green'><b>CSV file '\" + filename + \"' successfully created, download it here:</b></span><form action=\" + filename + \" target='_blank'><button type=''submit''>Download TEX</button></form>\"\n",
    "            exportTexName.value = ''\n",
    "            refreshFilesDropdown()\n",
    "        except:\n",
    "            exportTexText.value = \"<span style='color:red'><b>An error has occurred</b></span>\"\n",
    "            exportTexName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "exportTexButton.observe(exportTex, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "operationAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%'),\n",
    "    title = 'Operate with your columns'\n",
    ")\n",
    "\n",
    "operationAccordion.set_title(0, 'Operate with the columns')\n",
    "\n",
    "operationBox = widgets.VBox([])\n",
    "\n",
    "operationText = widgets.HTML(\n",
    "    value = \"You can operate with the colums: <b>new column = (constant x column1 ^ constant) operation (constant x column2 ^ constant)</b>\"    \n",
    ")\n",
    "\n",
    "finalColDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")\n",
    "\n",
    "equals = widgets.HTMLMath(\n",
    "    value = '\\( = \\)',\n",
    ")\n",
    "\n",
    "operationExpression = widgets.HTMLMath(\n",
    "    value = '\\( C1 = a \\cdot C2^{b} * c \\cdot C3^{d}\\)',\n",
    ")\n",
    "\n",
    "ber = widgets.HTMLMath(\n",
    "    value = '^',\n",
    ")\n",
    "\n",
    "const1 = widgets.FloatText(\n",
    "    value=1,\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width='80px'),\n",
    "    description = ''\n",
    ")\n",
    "\n",
    "const2 = widgets.FloatText(\n",
    "    value=1,\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width='80px'),\n",
    "    description = ''\n",
    ")\n",
    "\n",
    "const3 = widgets.FloatText(\n",
    "    value=1,\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width='50px'),\n",
    "    description = ''\n",
    ")\n",
    "\n",
    "const4 = widgets.FloatText(\n",
    "    value=1,\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width='50px'),\n",
    "    description = ''\n",
    ")\n",
    "\n",
    "dot = widgets.HTMLMath(\n",
    "    value = '\\( \\cdot \\)',\n",
    ")\n",
    "\n",
    "aColDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")\n",
    "\n",
    "opColDropdown = widgets.Dropdown(\n",
    "    options = ['+','-','x','/'],\n",
    "    description='',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")\n",
    "\n",
    "bColDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")\n",
    "\n",
    "operateButton = widgets.ToggleButton(\n",
    "    description='Calculate',\n",
    "    disabled=False,\n",
    "    button_style='',\n",
    "    layout = widgets.Layout(align_self = 'center')\n",
    ")\n",
    "\n",
    "operationBox.children = (widgets.HBox([widgets.VBox([finalColDropdown]),\n",
    "                         widgets.VBox([equals]),\n",
    "                         widgets.VBox([const1,const2]),\n",
    "                         widgets.VBox([dot,dot]),\n",
    "                         widgets.VBox([aColDropdown,bColDropdown]),\n",
    "                         widgets.VBox([ber,ber]),\n",
    "                         widgets.VBox([const3,const4]),\n",
    "                         widgets.VBox([opColDropdown])\n",
    "                                      ]),\n",
    "                         operateButton,\n",
    "                        )\n",
    "\n",
    "operationAccordion.children = (widgets.VBox([operationText, operationBox,]),)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculateColumn(change):\n",
    "    if operateButton.value:\n",
    "        operateButton.value = False\n",
    "        \n",
    "        op = opColDropdown.value\n",
    "        c1 = const1.value\n",
    "        c2 = const2.value\n",
    "        c3 = const3.value\n",
    "        c4 = const4.value\n",
    "        a = np.array(qGridCurrent.get_changed_df()[aColDropdown.value])\n",
    "        b = np.array(qGridCurrent.get_changed_df()[bColDropdown.value])\n",
    "\n",
    "        with np.errstate(divide='ignore'):\n",
    "            a = a**c3\n",
    "            a[a == np.inf] = 0\n",
    "            a = np.nan_to_num(a)\n",
    "\n",
    "            b = b**c4\n",
    "            b[b == np.inf] = 0\n",
    "            b = np.nan_to_num(b)\n",
    "\n",
    "        if op == '+':\n",
    "            new = c1*a + c2*b\n",
    "\n",
    "        elif op == '-':\n",
    "            new = c1*a - c2*b\n",
    "\n",
    "        elif op == 'x':\n",
    "            new = (c1*a) * (c2*b)\n",
    "\n",
    "\n",
    "        elif op == '/':\n",
    "\n",
    "            with np.errstate(divide='ignore', invalid='ignore'):\n",
    "                c = np.true_divide(c1*a,c2*b)\n",
    "                c[c == np.inf] = 0\n",
    "                new = np.nan_to_num(c)\n",
    "\n",
    "        df = qGridCurrent.get_changed_df()\n",
    "        df[finalColDropdown.value] = new\n",
    "        \n",
    "        qGridCurrent.df = df\n",
    "        qGridCurrent.df = qGridCurrent.df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "operateButton.observe(calculateColumn, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "chartBlock.children = chartBlock.children + (columnOptionsAccordion, rowOptionsAccordion, qGridCurrent, operationAccordion, exportAccordion )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "columnOptionsAccordion.children = (columnOptionsBox,)\n",
    "columnOptionsAccordion.set_title(0, 'Edit columns')\n",
    "\n",
    "columnOptionsBox.children = columnOptionsBox.children + (columnBox,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "rowOptionsAccordion.children = (rowOptionsBox,)\n",
    "rowOptionsAccordion.set_title(0, 'Edit rows')\n",
    "\n",
    "rowOptionsBox.children = rowOptionsBox.children + (rowBox,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotBox = widgets.VBox([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotterAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%')\n",
    ")\n",
    "\n",
    "plotterAccordion.set_title(0, 'Plot your data:')\n",
    "plotter = widgets.VBox([])\n",
    "\n",
    "plotterText = widgets.HTML(\n",
    "    value = \"<br><h2>Plot your data:</h2>\"    \n",
    ")\n",
    "\n",
    "plotterSelectors = widgets.VBox([])\n",
    "\n",
    "ySelector = widgets.Dropdown(\n",
    "    options = list(qGridCurrent.df),\n",
    "    description='<h6>Y axis: </h6>',\n",
    "    style = style_1,\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "xSelector = widgets.Dropdown(\n",
    "    options = list(qGridCurrent.df),\n",
    "    description='<h6>X axis: </h6>',\n",
    "    rows = 10,\n",
    "    style = style_1,\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "pointsColor = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#7800c8',\n",
    "    disabled=False,\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "\n",
    "replaceButton = widgets.ToggleButton(\n",
    "    description = 'Replace plot',\n",
    "    button_style = 'danger',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "addButton = widgets.ToggleButton(\n",
    "    description = 'Add to plot',\n",
    "    button_style = 'warning',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "liveUpdateCheckbox = widgets.Checkbox(\n",
    "    value=True,\n",
    "    description='Live update (If checked, changes in the data chart will update the plot) (experimental)',\n",
    "    description_tooltip = 'If checked, changes in the data chart will update the plot (experimental)'\n",
    ")\n",
    "\n",
    "                                \n",
    "plotterSelectors.children = [ widgets.HBox([xSelector, ySelector, pointsColor]),\n",
    "                              widgets.HBox([replaceButton, addButton], layout = widgets.Layout(align_self = 'center'))]\n",
    "\n",
    "plotter.children = [plotterSelectors, liveUpdateCheckbox]\n",
    "plotterAccordion.children = [plotter]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "liveUpdateCheckbox.description_tooltip = 'fidsaof`dsao`fds'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotBlock.children = plotBlock.children + (plotterText, plotter,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaleX = bqm.LinearScale(min = 0, max = 0)\n",
    "scaleY = bqm.LinearScale(min = 0, max = 0)\n",
    "\n",
    "axisX = bqa.Axis(scale=scaleX,\n",
    "                tick_format='0.2f',\n",
    "                tick_style={'font-size': '15px'},\n",
    "                num_ticks = 5,\n",
    "                grid_lines = 'dashed',\n",
    "                grid_color = '#8e8e8e', \n",
    "                label='x',\n",
    "                label_location='middle',\n",
    "                label_offset='0.5em')\n",
    "\n",
    "axisY = bqa.Axis(scale=scaleY,\n",
    "                tick_format='0.2f',\n",
    "                tick_style={'font-size': '15px'},\n",
    "                num_ticks = 4,\n",
    "                grid_lines = 'dashed',\n",
    "                grid_color = '#8e8e8e', \n",
    "                orientation='vertical',\n",
    "                label='y',\n",
    "                label_location='middle',\n",
    "                label_offset='50px')\n",
    "\n",
    "tooltipScat = bq.Tooltip(fields=['x', 'y'], labels=[ 'x', 'y'], formats=['4.2f', '4.2f'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "scat = bqm.Scatter(x = np.array([]), \n",
    "                   y = np.array([]), \n",
    "                   scales = {'x': scaleX, 'y': scaleY}, \n",
    "                   enable_move = False,\n",
    "                   tooltip = tooltipScat,\n",
    "                   restrict_x = False,\n",
    "                   restrict_y = False,\n",
    "                   selected_style={'opacity': '1'},\n",
    "                   unselected_style={'opacity': '0.2'},\n",
    "                   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "lin = bqm.Lines(x = np.array([]), \n",
    "                y = np.array([]), \n",
    "                scales = {'x': scaleX, 'y': scaleY}, \n",
    "                visible = False,\n",
    "                colors = ['#fad87c']\n",
    "                )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshPlotterSelectors(change):\n",
    "    xSelector.options = list(qGridCurrent.df)\n",
    "    ySelector.options = list(qGridCurrent.df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataDropdown.observe(refreshPlotterSelectors, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshDimensions(dataX, dataY, scatter=scat, line=lin):\n",
    "    \n",
    "    index = []\n",
    "    \n",
    "    for i in range(len(dataX)):\n",
    "        if isNotNumber(dataX[i]) or isNotNumber(dataY[i]):\n",
    "            index.append(i)\n",
    " \n",
    "    dataX = np.delete(dataX, index).astype(np.float)\n",
    "    dataY = np.delete(dataY, index).astype(np.float)\n",
    "    \n",
    "    dataMinX = min(dataX)\n",
    "    dataMaxX = max(dataX)\n",
    "    \n",
    "    dataMinY = min(dataY)\n",
    "    dataMaxY = max(dataY)\n",
    "    \n",
    "    dataWidth  = dataMaxX - dataMinX\n",
    "    dataHeight = dataMaxY - dataMinY\n",
    "    \n",
    "    if dataWidth == 0.0:\n",
    "        dataWidth = 10.0\n",
    "    \n",
    "    if dataHeight == 0.0:\n",
    "        dataHeight = 10.0\n",
    "    \n",
    "    scaleX = bqm.LinearScale(min = dataMinX - 0.1*dataWidth, max = dataMaxX + 0.1*dataWidth)\n",
    "    scaleY = bqm.LinearScale(min = dataMinY - 0.1*dataHeight, max = dataMaxY + 0.1*dataHeight)\n",
    "\n",
    "    axisX.scale = scaleX\n",
    "    axisY.scale = scaleY\n",
    "    \n",
    "    scatter.scales = {'x': scaleX, 'y': scaleY}\n",
    "    line.scales = {'x': scaleX, 'y': scaleY}\n",
    "\n",
    "    pz.scales = {'x': [scaleX], 'y': [scaleY]}\n",
    "    pzx.scales = {'x': [scaleX]}\n",
    "    pzy.scales = {'y': [scaleY]}\n",
    "\n",
    "    squareSel.x_scale = scaleX\n",
    "    squareSel.y_scale = scaleY\n",
    "        \n",
    "    sim_pz.scales = {'x': [scaleX], 'y': [scaleY]}\n",
    "    sim_pzx.scales = {'x': [scaleX]}\n",
    "    sim_pzy.scales = {'y': [scaleY]}\n",
    "\n",
    "    sim_squareSel.x_scale = scaleX\n",
    "    sim_squareSel.y_scale = scaleY"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def replacePlot(change):\n",
    "    \n",
    "    replaceButton.value = False\n",
    "    \n",
    "    addPointsButton.value = False\n",
    "    removePointsButton.value = False\n",
    "\n",
    "    data = db.getData(dataDropdown.value)\n",
    "\n",
    "    dataX = qGridCurrent.get_changed_df().get(xSelector.value).values \n",
    "    dataY = qGridCurrent.get_changed_df().get(ySelector.value).values \n",
    "\n",
    "    if dataX is not None and dataY is not None:\n",
    "\n",
    "        if len(dataX) > 1:\n",
    "\n",
    "            refreshDimensions(dataX, dataY)\n",
    "\n",
    "            scat.observe(null)\n",
    "\n",
    "            [scat.x, scat.y] = dataX, dataY\n",
    "            scat.colors = [pointsColor.value for elem in dataX]\n",
    "            \n",
    "            scat.selected = None\n",
    "            \n",
    "            showRegressionCheckbox.value = False\n",
    "            showEstimatedCheckbox.value = False\n",
    "            showDistancesCheckbox.value = False\n",
    "\n",
    "            lin.x = np.array([])\n",
    "            lin.y = np.array([])\n",
    "\n",
    "            axisX.label = xSelector.value\n",
    "            axisY.label = ySelector.value\n",
    "            \n",
    "            mainPlot.marks = [dist, scatEstimated, lin,scat]\n",
    "            mainPlot.axes = ([axisX, axisY])\n",
    "            mainPlot.title = ''\n",
    "            \n",
    "            w = widgets.VBox(children = [widgets.HTML(value='<br/>'), zoom_interacts, compressZoomButton, ResetZoomButton], layout = widgets.Layout(width='10%'))\n",
    "            v = widgets.HBox([mainPlot, w])\n",
    "            \n",
    "            mainPlotBox.children = (v,                                    \n",
    "                                    widgets.HBox([simulationName, simulateButton, changeViewButton]))\n",
    "            \n",
    "            plotBlock.children = [plotterText, plotter, plotOptionsAccordion, mainPlotBox, regressionOptionsAccordion, exportPlotAccordion]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "replaceButton.observe(replacePlot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addToPlot(change):\n",
    "    \n",
    "    if addButton.value:\n",
    "        addButton.value = False\n",
    "\n",
    "        addPointsButton.value = False\n",
    "        removePointsButton.value = False\n",
    "\n",
    "        data = db.getData(dataDropdown.value)\n",
    "  \n",
    "        dataX = np.append(data.get(xSelector.value).values, scat.x)\n",
    "        dataY = np.append(data.get(ySelector.value).values, scat.y)\n",
    "\n",
    "        colors = scat.colors\n",
    "        \n",
    "        if len(scat.x) != 0 and len(scat.y) != 0:\n",
    "\n",
    "            refreshDimensions(dataX, dataY)\n",
    "\n",
    "            for i in range(len(data.get(xSelector.value))):\n",
    "                colors.append(pointsColor.value)\n",
    "\n",
    "            scat.colors = colors    \n",
    "                \n",
    "            [scat.x, scat.y] = dataX, dataY\n",
    "\n",
    "            scat.selected = None\n",
    "\n",
    "            updateRegression(change)\n",
    "            updateDistances(change)\n",
    "            \n",
    "        else:            \n",
    "            replacePlot(change)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "addButton.observe(addToPlot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "mainPlot = bq.Figure(title='',\n",
    "                marks=[],\n",
    "                axes=[],\n",
    "                animation_duration=500,\n",
    "                layout = widgets.Layout(width='80%', align_self='center'),\n",
    "                legend_location='top-right',\n",
    "                background_style= {'fill': 'white',  'stroke': 'black'},\n",
    "                fig_margin=dict(top=80, bottom=80, left=75, right=20)\n",
    "               )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "mainPlotBox = widgets.VBox([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "mainPlotBox.display = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def null(change):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "pz = bq.interacts.PanZoom(allow_pan = True,\n",
    "                          allow_zoom = True,\n",
    "                          scales={'x': [mainPlot.scale_x], 'y': [mainPlot.scale_y]})\n",
    "\n",
    "pzx = bq.interacts.PanZoom(allow_pan = True,\n",
    "                          allow_zoom = True,\n",
    "                           scales={'x': [mainPlot.scale_x]})\n",
    "\n",
    "pzy = bq.interacts.PanZoom(allow_pan = True,\n",
    "                          allow_zoom = True,\n",
    "                           scales={'y': [mainPlot.scale_y], })\n",
    "\n",
    "squareSel = bq.interacts.BrushSelector(marks=[scat], x_scale=mainPlot.scale_x, y_scale=mainPlot.scale_y)\n",
    "handSel = bq.interacts.LassoSelector(marks=[scat])\n",
    "\n",
    "#icons from https://fontawesome.com/v4.7.0/icons/\n",
    "zoom_interacts = widgets.ToggleButtons(\n",
    "                                        value = None,\n",
    "                                        options=[\n",
    "                                            ('xy ', pz), \n",
    "                                            ('x ', pzx), \n",
    "                                            ('y ', pzy),  \n",
    "                                            (' ', squareSel),\n",
    "                                            (' ', handSel),\n",
    "                                            (' ', None),],\n",
    "                                            icons = [\"arrows\", \"arrows-h\", \"arrows-v\", \"pencil-square-o\", \"pencil\", \"stop\"],\n",
    "                                            tooltips = [\"zoom/pan in x & y\",\n",
    "                                                        \"zoom/pan in x only\",\n",
    "                                                        \"zoom/pan in y only\",\n",
    "                                                        \"square selector\",\n",
    "                                                        \"lasso selector\",\n",
    "                                                        \"cancel interaction\"],\n",
    "                                        layout = widgets.Layout(\n",
    "                                            width = '50px',\n",
    "                                            margin_left = '0px',\n",
    "                                            margin_right = '0px'\n",
    "                                        ),\n",
    "                                        style = {'button_width' : '50px'}\n",
    "                                        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "link((zoom_interacts, 'value'), (mainPlot, 'interaction'));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "ResetZoomButton = widgets.Button(\n",
    "    description='',\n",
    "    disabled=False,\n",
    "    button_style='',\n",
    "    tooltip='Reset zoom',\n",
    "    icon='arrows-alt',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def resetZoom(new):\n",
    "    refreshDimensions(scat.x, scat.y)\n",
    "    updateDistances(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "ResetZoomButton.on_click(resetZoom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "compressZoomButton = widgets.Button(\n",
    "    description='',\n",
    "    disabled=False,\n",
    "    button_style='',\n",
    "    tooltip='Zoom to selected area',\n",
    "    icon='compress',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compressZoom(new):\n",
    "    if scat.selected != None:\n",
    "        if len(scat.selected) > 2:\n",
    "            dataX = np.take(scat.x, scat.selected)\n",
    "            dataY = np.take(scat.y, scat.selected)   \n",
    "            refreshDimensions(dataX, dataY)\n",
    "            updateDistances(None)\n",
    "            zoom_interacts.value = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "compressZoomButton.on_click(compressZoom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotOptionsBox = widgets.VBox([])\n",
    "\n",
    "plotOptionsAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%')\n",
    ")\n",
    "\n",
    "\n",
    "plotOptionsAccordion.set_title(0, 'Plot options')\n",
    "plotOptionsAccordion.children = (plotOptionsBox, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkboxes = widgets.HBox([], layout = widgets.Layout(align_self = 'center', width = '100%'))\n",
    "\n",
    "grid = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Show grid',\n",
    ")\n",
    "\n",
    "legendBold = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Bold legend',\n",
    ")\n",
    "\n",
    "numbersBold = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Bold numbers',\n",
    ")\n",
    "\n",
    "checkboxes.children = (grid, numbersBold, )\n",
    "plotOptionsBox.children = plotOptionsBox.children + (checkboxes,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "def updatePlotCheckboxes(change):\n",
    "    \n",
    "    if grid.value:\n",
    "        axisX.grid_lines = 'dashed'\n",
    "        axisY.grid_lines = 'dashed'\n",
    "        \n",
    "    else:\n",
    "        axisX.grid_lines = 'none'\n",
    "        axisY.grid_lines = 'none'\n",
    "        \n",
    "    if numbersBold.value:\n",
    "        axisX.tick_style={'stroke': 'black', 'font-size': '15px'}\n",
    "        axisY.tick_style={'stroke': 'black', 'font-size': '15px'}\n",
    "        \n",
    "    else:\n",
    "        axisX.tick_style={'stroke': 'none', 'font-size': '15px'}\n",
    "        axisY.tick_style={'stroke': 'none', 'font-size': '15px'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "grid.observe(updatePlotCheckboxes, 'value')\n",
    "numbersBold.observe(updatePlotCheckboxes, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "renamePlotBox = widgets.HBox([])\n",
    "\n",
    "plotTitle = widgets.Text(\n",
    "    value= '',\n",
    "    placeholder=\"Type plot's new title\",\n",
    "    description='Plot name:',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "renamePlotButton = widgets.ToggleButton(\n",
    "    description = 'Rename plot',\n",
    "    button_style = 'warning',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "renamePlotBox.children = (plotTitle, renamePlotButton)\n",
    "plotOptionsBox.children = plotOptionsBox.children + (renamePlotBox,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "def renamePlot(change):\n",
    "    \n",
    "    if renamePlotButton.value:\n",
    "        renamePlotButton.value = False\n",
    "        mainPlot.title = str(plotTitle.value)\n",
    "        plotTitle.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "renamePlotButton.observe(renamePlot, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "renameAxisBox = widgets.VBox([])\n",
    "\n",
    "xName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type X axis' new title\",\n",
    "    description='X axis:',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "renameXAxis = widgets.ToggleButton(\n",
    "    description = 'Rename X',\n",
    "    button_style = 'warning',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "yName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type Y axis' new title\",\n",
    "    description='Y axis:',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "renameYAxis = widgets.ToggleButton(\n",
    "    description = 'Rename Y',\n",
    "    button_style = 'warning',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "renameAxisBox.children = (widgets.HBox([xName, renameXAxis]),\n",
    "                          widgets.HBox([yName, renameYAxis]))\n",
    "\n",
    "plotOptionsBox.children = plotOptionsBox.children + (renameAxisBox,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "def renameAxis(change):\n",
    "    \n",
    "    if renameXAxis.value:\n",
    "        renameXAxis.value = False\n",
    "        axisX.label = xName.value\n",
    "        xName.value = ''\n",
    "        \n",
    "    if renameYAxis.value:\n",
    "        renameYAxis.value = False\n",
    "        axisY.label = yName.value   \n",
    "        yName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "renameXAxis.observe(renameAxis, 'value')\n",
    "renameYAxis.observe(renameAxis, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionOptionsAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%')\n",
    ")\n",
    "\n",
    "\n",
    "regressionOptionsAccordion.set_title(0, 'Regression')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionOptionsBox = widgets.VBox([])\n",
    "\n",
    "regressionBox = widgets.VBox([])\n",
    "\n",
    "showRegressionCheckbox = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Show regression',\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "regressionColor = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#fad87c',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "regressionOpacity = widgets.FloatSlider(\n",
    "    value=1.0,\n",
    "    min=0,\n",
    "    max=1.0,\n",
    "    step=0.05,\n",
    "    description='Opacity:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width = '350px')\n",
    ")\n",
    "\n",
    "regressionBox.children = (widgets.HTML(value='<h4>Edit regression:</h4>'), widgets.HBox([regressionColor, regressionOpacity]))\n",
    "\n",
    "regressionOptionsBox.children = (showRegressionCheckbox,)\n",
    "regressionOptionsAccordion.children = (regressionOptionsBox,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "def showRegression(change):\n",
    "    \n",
    "    if showRegressionCheckbox.value:\n",
    "        lin.visible = True\n",
    "        updateRegression(change)\n",
    "        updateDistances(change)\n",
    "        \n",
    "    else:\n",
    "        lin.visible = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "showRegressionCheckbox.observe(showRegression, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeRegressionColor(change):\n",
    "    lin.colors = [regressionColor.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionColor.observe(changeRegressionColor, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeRegressionOpacity(change):\n",
    "    lin.opacities = [regressionOpacity.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionOpacity.observe(changeRegressionOpacity, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionDecimals = widgets.Dropdown(\n",
    "    options = [i for i in range(0,14)],\n",
    "    value = 2,\n",
    "    description='<h4>Number of decimals: </h4>',\n",
    "    style = style_1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionOrder = widgets.IntSlider(\n",
    "    value=1.0,\n",
    "    min=1.0,\n",
    "    max=5.0,\n",
    "    description='',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "regressionErrorText = widgets.HTML(\n",
    "    value = \"\",\n",
    ")\n",
    "\n",
    "regressionValues = widgets.VBox()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "def updateRegression(change):\n",
    "\n",
    "    if regressionExpression not in regressionOptionsBox.children:\n",
    "    \n",
    "        regressionOptionsBox.children = [widgets.HBox([showRegressionCheckbox, widgets.Label('Order of regression'),regressionOrder,]),\n",
    "                                        regressionExpression,\n",
    "                                        regressionValues,\n",
    "                                        regressionDecimals,\n",
    "                                        widgets.HTML(value='<br>'),\n",
    "                                        widgets.HBox([showDistancesCheckbox,showEstimatedCheckbox]),\n",
    "                                        widgets.HTML(value='<hr>'),\n",
    "                                        regressionBox,\n",
    "                                        distancesBox,\n",
    "                                        estimatedBox\n",
    "                                        ]\n",
    "\n",
    "    if scat.selected == None:\n",
    "        \n",
    "        dataX = scat.x\n",
    "        dataY = scat.y\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        if len(scat.selected) < 3:\n",
    "        \n",
    "            dataX = scat.x\n",
    "            dataY = scat.y\n",
    "        \n",
    "        else:\n",
    "            \n",
    "            dataX = np.take(scat.x, scat.selected)\n",
    "            dataY = np.take(scat.y, scat.selected)    \n",
    "            \n",
    "    lin.x = np.linspace(start=np.min(dataX), stop=np.max(dataX), num=1000)\n",
    "    \n",
    "    try:\n",
    "        if len(dataX) > regressionOrder.value + 1:\n",
    "            poly, cov = np.polyfit(dataX, dataY, regressionOrder.value, cov=True)\n",
    "            regressionErrorText.value = ''\n",
    "\n",
    "        else:\n",
    "            poly = np.polyfit(dataX, dataY, len(dataX) - 1)\n",
    "            cov = np.zeros([len(poly),len(poly)])\n",
    "            \n",
    "            if regressionOrder.value >= len(dataX):\n",
    "                regressionErrorText.value = \"<span style='color:red'><b>You need more points for a regression of order \" + str(regressionOrder.value) + \"</b></span>\"\n",
    "            else:\n",
    "                regressionErrorText.value = ''\n",
    "    except:\n",
    "        return None\n",
    "    lin.y = np.polyval(poly, lin.x)\n",
    "    \n",
    "    \n",
    "    if squareSel.brushing == False:\n",
    "    \n",
    "        expression = '\\(y = \\;\\)'\n",
    "        maxPower = len(poly)-1\n",
    "\n",
    "        decimals = regressionDecimals.value\n",
    "        chars = 'abcdef'\n",
    "\n",
    "        errors = np.sqrt(np.diag(cov))\n",
    "\n",
    "        regressionValues.children = []\n",
    "\n",
    "        for i in range(len(poly)):\n",
    "\n",
    "            coef = np.around([ poly[i],],decimals)[0]\n",
    "\n",
    "            error = np.around([errors[i],], decimals)[0]\n",
    "\n",
    "            power = maxPower-i\n",
    "\n",
    "            if power == 1:\n",
    "\n",
    "                expression = expression + '\\(' + chars[i] + '\\; x \\; + \\; \\)' \n",
    "\n",
    "            elif power == 0:\n",
    "                expression = expression + '\\(' + chars[i] + ' \\)'\n",
    "\n",
    "            else:\n",
    "                expression = expression + '\\(' + chars[i] + '\\; x^{' + str(power) + '} \\; + \\; \\)'\n",
    "\n",
    "            s = '\\(' + chars[i] + '\\; = \\; ' + str(coef) + '\\; \\pm \\;' + str(error) + '\\)'\n",
    "            regressionValues.children = regressionValues.children + (widgets.HTMLMath(value = s , description = ''), )\n",
    "\n",
    "        regressionExpression.value = expression\n",
    "        errors = np.sqrt(np.diag(cov))\n",
    "        errorsExp = ''\n",
    "\n",
    "        for error in errors:\n",
    "            error = np.around([error,], decimals)[0]\n",
    "            errorsExp = errorsExp + '\\(' + str(error) + '\\; \\; \\; \\)'\n",
    "\n",
    "        errorsExpression.value = errorsExp    \n",
    "\n",
    "    updateDistances(change)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionOrder.observe(updateRegression, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionDecimals.observe(updateRegression, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "scat.observe(updateRegression, 'selected')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "squareSel.observe(updateRegression, 'brushing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "regressionExpression = widgets.HTMLMath(\n",
    "    value = '\\(y =\\)',\n",
    "    description = 'Expression:'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "errorsExpression = widgets.HTMLMath(\n",
    "    value = '\\(',\n",
    "    description = 'Errors:'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "simulationName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Type your simulation's name (optional):\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "simulateButton = widgets.ToggleButton(\n",
    "    description = 'Simulate',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulate(change):\n",
    "    if simulateButton.value:\n",
    "        simulateButton.value = False\n",
    "        pb.addSimulation(mainPlot, simulationName.value)\n",
    "        pb.addPlot(mainPlot, simulationName.value)\n",
    "        refreshPlotDropdown()\n",
    "        refreshSimDropdown()\n",
    "        changeViewButton.value = True\n",
    "        simulationName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "simulateButton.observe(simulate,'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "pngName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Save as (optional):\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "savePNGButton = widgets.ToggleButton(\n",
    "    description = 'Save as PNG',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "pngCreatedText = widgets.HTML(\n",
    "    value = \"\",\n",
    "    ) \n",
    "\n",
    "pdfName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Save as (optional):\",\n",
    "    disabled = False,\n",
    ")\n",
    "\n",
    "savePDFButton = widgets.ToggleButton(\n",
    "    description = 'Save as PDF',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "    \n",
    "pdfCreatedText = widgets.HTML(\n",
    "    value = \"\",\n",
    "    ) \n",
    "\n",
    "exportPlotAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%'),\n",
    "    title = 'Export your chart'\n",
    ")\n",
    "\n",
    "exportPlotAccordion.set_title(0, 'Export your plot')\n",
    "\n",
    "exportPlotBox = widgets.VBox()\n",
    "exportPlotBox.children = [widgets.HBox([pdfName,savePDFButton], layout = widgets.Layout(align_self = 'center')),\n",
    "                        widgets.HBox([pdfCreatedText]),\n",
    "                        widgets.HBox([pngName,savePNGButton], layout = widgets.Layout(align_self = 'center')),\n",
    "                        widgets.HBox([pngCreatedText]),]\n",
    "\n",
    "exportPlotAccordion.children = (exportPlotBox,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matplotlib_figure(pdf, png, fig=mainPlot):\n",
    "\n",
    "    plt.ioff()\n",
    "    \n",
    "    s = fig.marks[3]\n",
    "    l = fig.marks[2]\n",
    "    \n",
    "    ax = fig.axes[0]\n",
    "    ay = fig.axes[1]\n",
    "    \n",
    "    # irudiaren diseinuerako\n",
    "    plt.rc('text', usetex=True)\n",
    "    mpl.rcParams['errorbar.capsize'] = 3\n",
    "    colors_ = list(mcolors.TABLEAU_COLORS.values())\n",
    "       \n",
    "    # irudiko eskalak definitzeko: hobetu egin behar da, balioen eta tarteen arabera egokiak diren tick-en kopurua finkatzeko, beti kopuru txikia izanik  \n",
    "    \n",
    "    if fig.marks[3].selected == None:\n",
    "        \n",
    "        dataX = fig.marks[3].x\n",
    "        dataY = fig.marks[3].y\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        if len(fig.marks[3].selected) < 3:\n",
    "        \n",
    "            dataX = fig.marks[3].x\n",
    "            dataY = fig.marks[3].y\n",
    "        \n",
    "        else:\n",
    "            \n",
    "            dataX = np.take(fig.marks[3].x, fig.marks[3].selected)\n",
    "            dataY = np.take(fig.marks[3].y, fig.marks[3].selected)    \n",
    "\n",
    "    \n",
    "    x_min, x_max, y_min, y_max = min(dataX), max(dataX), min(dataY), max(dataY)\n",
    "\n",
    "    # irudia\n",
    "    fig_pdf, ax0 = plt.subplots(nrows=1, ncols=1, figsize=(16, 12), );\n",
    "    plt.subplots_adjust(left=0.25, bottom=0.25, right=0.9, top=None, wspace=0.0, hspace=0.0)\n",
    "    ax0.tick_params(axis='both', labelsize=30, pad=10, length=12)\n",
    "   \n",
    "    # limeteak\n",
    "    \n",
    "    dataWidth = x_max - x_min\n",
    "    dataHeight = y_max - y_min\n",
    "    \n",
    "    ax0.set_xlim(x_min-dataWidth*0.1, x_max+dataWidth*0.1)\n",
    "    ax0.set_ylim(y_min-dataHeight*0.1, y_max+dataHeight*0.1)\n",
    "\n",
    "    # ticks\n",
    "    ax0.yaxis.set_major_locator(mpl.ticker.NullLocator());\n",
    "    ax0.xaxis.set_major_locator(mpl.ticker.NullLocator());\n",
    "    \n",
    "    #plt.xticks()\n",
    "    \n",
    "    ax0.yaxis.set_major_locator(plt.MaxNLocator(nbins=ay.num_ticks));\n",
    "    ax0.xaxis.set_major_locator(plt.MaxNLocator(nbins=ax.num_ticks));\n",
    "\n",
    "    # etiketak\n",
    "    if len(fig.title.split()) > 0: \n",
    "        ax0.set_title(r'\\textrm{%s}' % fig.title, size=35, pad=20)\n",
    "    ax0.set_xlabel(r'\\textrm{%s}' % ax.label, size=30, labelpad=15)\n",
    "    ax0.set_ylabel(r'\\textrm{%s}' % ay.label, size=30, labelpad=15)\n",
    "\n",
    "    # Legendan agertuko dena, defektuz finkoa da, baina beti aldatu daiteke\n",
    "    labels = [r'\\textrm{Data}', r'$\\textrm{Regression}$']\n",
    "   \n",
    "    # datuak irudikatu\n",
    "    ax0.scatter(dataX, dataY, label=labels[0], color=fig.marks[3].colors[0], s=180);\n",
    "    \n",
    "    order = [0]\n",
    "    \n",
    "    if showRegressionCheckbox.value:\n",
    "        ax0.plot(fig.marks[2].x, fig.marks[2].y, label=labels[1], color=fig.marks[2].colors[0], lw=5, alpha=0.5);\n",
    "        order.append(1)\n",
    "        \n",
    "    # egokia den ordenean legendakoak adierazteko\n",
    "    handles, labels = plt.gca().get_legend_handles_labels()\n",
    "\n",
    "    plt.legend([handles[idx] for idx in order],[labels[idx] for idx in order])\n",
    "    ax0.legend(bbox_transform=ax0.transAxes,\n",
    "               #bbox_to_anchor=(0.95, 0.30),\n",
    "               loc='best',\n",
    "               ncol=1,\n",
    "               borderaxespad=1.5,\n",
    "               frameon=False,\n",
    "               fontsize=25);\n",
    "   \n",
    "    # doiketaren emaitzak irudian bertan idazteko\n",
    "    if showRegressionCheckbox.value:\n",
    "        fig_pdf.text(0.5, -0.25, regressionExpression.value, size=25, horizontalalignment='center', rotation='horizontal', transform=ax0.transAxes);\n",
    "        \n",
    "        space = -0.35\n",
    "        for error in regressionValues.children:\n",
    "            fig_pdf.text(0.5, space, error.value, size=25, horizontalalignment='center', rotation='horizontal', transform=ax0.transAxes);\n",
    "            space = space - 0.075\n",
    "            \n",
    "    # irudia gorde\n",
    "    if pdf:\n",
    "        save_filename = pdfName.value\n",
    "\n",
    "        if len(save_filename.split()) == 0:\n",
    "            save_filename = 'pdf_file'\n",
    "\n",
    "        if '.pdf' not in save_filename:\n",
    "            save_filename = save_filename + '.pdf'\n",
    "\n",
    "        plt.savefig(save_filename, format='pdf', dpi=150, bbox_inches=\"tight\");\n",
    "        return (save_filename)\n",
    "    \n",
    "    if png:\n",
    "        save_filename = pngName.value\n",
    "        if len(save_filename.split()) == 0:\n",
    "            save_filename = 'png_file'\n",
    "\n",
    "        if '.png' not in save_filename:\n",
    "            save_filename = save_filename + '.png'\n",
    "        plt.savefig(save_filename, format='png', dpi=150, bbox_inches=\"tight\");\n",
    "        return (save_filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "def savePDF(change):\n",
    "    if savePDFButton.value:\n",
    "        savePDFButton.value = False\n",
    "        \n",
    "        try:\n",
    "            pdfCreatedText.value =\"<b>Creating PDF file...</b>\"\n",
    "            filename = matplotlib_figure(pdf = True, png = False, fig = mainPlot)\n",
    "            pdfCreatedText.value = \"<span style='color:green'><b>PDF file '\" + filename + \"' successfully created, download it here:</b></span><form action=\" + filename + \" target='_blank'><button type=''submit''>Download PDF</button></form>\"\n",
    "            pdfName.value = ''\n",
    "\n",
    "        except:\n",
    "            pdfCreatedText.value = \"<span style='color:red'><b>An error has occurred</b></span>\"\n",
    "            pdfName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "savePDFButton.observe(savePDF, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "def savePNG(change):\n",
    "    if savePNGButton.value:\n",
    "        savePNGButton.value = False\n",
    "        \n",
    "        try:\n",
    "            pngCreatedText.value =\"<b>Creating PNG file...</b>\"\n",
    "            filename = matplotlib_figure(pdf = False, png = True, fig = mainPlot)\n",
    "            pngCreatedText.value = \"<span style='color:green'><b>PNG file '\" + filename + \"' successfully created, download it here:</b></span><form action=\" + filename + \" target='_blank'><button type=''submit''>Download PNG</button></form>\"\n",
    "            pngName.value = ''\n",
    "\n",
    "        except:\n",
    "            pngCreatedText.value = \"<span style='color:red'><b>An error has occurred</b></span>\"\n",
    "            pngName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "savePNGButton.observe(savePNG, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatEstimated = bqm.Scatter(x = np.array([]),\n",
    "                             y = np.array([]),\n",
    "                             scales = {'x': scaleX, 'y': scaleY},\n",
    "                             enable_move = False,\n",
    "                             visible = False,\n",
    "                            colors = ['#f87878']\n",
    "                            )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "dist = bqm.Lines(x = np.array([]),\n",
    "                 y = np.array([]),\n",
    "                 scales = {'x': scaleX, 'y': scaleY},\n",
    "                 line_style = 'dashed',\n",
    "                 visible = False,\n",
    "                 colors = ['#cdb4c8'],\n",
    "                 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "def updateDistances(change):\n",
    "\n",
    "    scaleX = scat.scales.get('x')\n",
    "    scaleY = scat.scales.get('y')\n",
    "    \n",
    "    dist.scales = {'x': scaleX, 'y': scaleY}\n",
    "    scatEstimated.scales = {'x': scaleX, 'y': scaleY}\n",
    "    \n",
    "    x = scat.x\n",
    "    y = scat.y\n",
    "    \n",
    "    try:\n",
    "        yInterp = np.interp(x, lin.x, lin.y) \n",
    "    \n",
    "    except:\n",
    "        return None\n",
    "    \n",
    "    scatEstimated.x = x\n",
    "    scatEstimated.y = yInterp    \n",
    "    \n",
    "    xVal = []\n",
    "    yVal = []\n",
    "\n",
    "    for i in range(len(x)):\n",
    "        for j in range(2):\n",
    "            xVal.append(x[i])\n",
    "        yVal.append(min(y[i],yInterp[i]))\n",
    "        yVal.append(max(y[i],yInterp[i]))\n",
    "        \n",
    "    xDef = []\n",
    "    yDef = []\n",
    "\n",
    "    for i in range(0, len(xVal), 2):\n",
    "        xDef.append(np.array([xVal[i], xVal[i+1]]))\n",
    "        yDef.append(np.array([yVal[i], yVal[i+1]]))\n",
    "        \n",
    "    dist.x = xDef\n",
    "    dist.y = yDef"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "distancesBox = widgets.VBox([])\n",
    "\n",
    "showDistancesCheckbox = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Show distances',\n",
    ")\n",
    "\n",
    "distancesColor = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#cdb4c8',\n",
    "    disabled=False,\n",
    ")\n",
    "\n",
    "distancesOpacity = widgets.FloatSlider(\n",
    "    value=1.0,\n",
    "    min=0,\n",
    "    max=1.0,\n",
    "    step=0.05,\n",
    "    description='Opacity:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width='350px')\n",
    ")\n",
    "\n",
    "distancesBox.children = (widgets.HTML(value='<h4>Edit distances:</h4>'), widgets.HBox([distancesColor, distancesOpacity]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "def showDistances(change):\n",
    "    \n",
    "    if showDistancesCheckbox.value:\n",
    "        dist.visible = True\n",
    "        updateRegression(change)\n",
    "        \n",
    "    else:\n",
    "        dist.visible = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "showDistancesCheckbox.observe(showDistances, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeDistancesColor(change):\n",
    "    dist.colors = [distancesColor.value for elem in dist.x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "distancesColor.observe(changeDistancesColor, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeDistancesOpacity(change):\n",
    "    dist.opacities = [distancesOpacity.value for elem in dist.x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "distancesOpacity.observe(changeDistancesOpacity, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimatedBox = widgets.VBox([])\n",
    "\n",
    "showEstimatedCheckbox = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Show estimated points',\n",
    ")\n",
    "\n",
    "estimatedColor = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#f87878',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "estimatedOpacity = widgets.FloatSlider(\n",
    "    value=1.0,\n",
    "    min=0,\n",
    "    max=1.0,\n",
    "    step=0.05,\n",
    "    description='Opacity:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width='350px')\n",
    ")\n",
    "\n",
    "estimatedBox.children = (widgets.HTML(value='<h4>Edit estimated points:</h4>'), widgets.HBox([estimatedColor, estimatedOpacity]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [],
   "source": [
    "def showEstimated(change):\n",
    "    \n",
    "    if showEstimatedCheckbox.value:\n",
    "        scatEstimated.visible = True\n",
    "        updateRegression(change)\n",
    "        \n",
    "    else:\n",
    "        scatEstimated.visible = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "showEstimatedCheckbox.observe(showEstimated, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeEstimatedColor(change):\n",
    "    scatEstimated.colors = [estimatedColor.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimatedColor.observe(changeEstimatedColor, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeEstimatedOpacity(change):\n",
    "    scatEstimated.default_opacities = [estimatedOpacity.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimatedOpacity.observe(changeEstimatedOpacity, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_plot_old(event, widget): \n",
    "\n",
    "    df = qGridCurrent.get_changed_df()\n",
    "\n",
    "    old = event.get('old')\n",
    "    index = event.get('index')\n",
    "    new = event.get('new')\n",
    "\n",
    "    if index < len(scat.x):\n",
    "        try:\n",
    "            dataX = scat.x\n",
    "            dataY = scat.y    \n",
    "\n",
    "            if old in dataX:\n",
    "                scat.x = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]\n",
    "                scatIndex = np.where(dataX == old)[0]\n",
    "                row = df.iloc[index].values\n",
    "\n",
    "                indexes = [index for index in scatIndex if dataY[index] in row]\n",
    "\n",
    "                for i in indexes:\n",
    "                    dataX[i] = new                \n",
    "                scat.x = dataX.tolist()\n",
    "\n",
    "\n",
    "            elif old in dataY:\n",
    "                scat.y = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]\n",
    "                scatIndex = np.where(dataY == old)[0]\n",
    "                row = df.iloc[index].values\n",
    "                indexes = [index for index in scatIndex if dataX[index] in row][0]\n",
    "                dataY[indexes] = new                \n",
    "                scat.y = dataY.tolist()\n",
    "\n",
    "            refreshDimensions(dataX, dataY)\n",
    "            updateRegression(None)\n",
    "            updateDistances(None)\n",
    "\n",
    "        except:\n",
    "            return None     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_plot(event, widget): \n",
    "\n",
    "    \n",
    "    if liveUpdateCheckbox.value:\n",
    "        \n",
    "        replacePlot(None)       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "qGridCurrent.on(names = ['cell_edited'], handler = update_plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "bottomBlock = widgets.HBox([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "changeViewButton = widgets.ToggleButton(\n",
    "    disabled=False,\n",
    "    button_style='',\n",
    "    description='See simulations',\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeView(change):\n",
    "    \n",
    "    if changeViewButton.value:\n",
    "        changeViewButton.value = False \n",
    "        \n",
    "        if len(plotDropdown.options) > 0:\n",
    "            description = changeViewButton.description\n",
    "\n",
    "            if description == 'See simulations':\n",
    "                changeViewButton.description = 'See data'\n",
    "                zoom_interacts.value = None\n",
    "                bodyBlock.children = [savedBlock, simBlock]\n",
    "                refreshSimDropdown()\n",
    "                refreshPlotDropdown()\n",
    "                refreshDimensions(simScat.x, simScat.y, simScat, simLin)\n",
    "                simShowRegressionCheckbox.value = showRegressionCheckbox.value\n",
    "                changeViewButton.layout = widgets.Layout(align_self = 'center')\n",
    "                \n",
    "            else:\n",
    "                changeViewButton.description = 'See simulations'\n",
    "                changeViewButton.layout = widgets.Layout()\n",
    "                bodyBlock.children = [chartBlock, plotBlock]\n",
    "                refreshDimensions(scat.x, scat.y)\n",
    "                sim_zoom_interacts.value = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "changeViewButton.observe(changeView, 'value')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "simBlock = widgets.VBox([], layout=widgets.Layout(width='50%', border='solid 1px', padding='20px'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "simDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    description='<h4>Choose your simulations: </h4>',\n",
    "    style = {'description_width': 'initial'},\n",
    "    layout = widgets.Layout(width = '100%')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshSimDropdown():\n",
    "    simDropdown.options = pb.getSimulations()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changeSim(change):\n",
    "    name = simDropdown.value\n",
    "    figure = pb.getPlot(name)\n",
    "    addPointsButton.value = False\n",
    "    dragXButton.value = False\n",
    "    dragYButton.value = False\n",
    "    \n",
    "    simPlot.title = figure.title\n",
    "\n",
    "    d = figure.marks[0] #distances\n",
    "    se = figure.marks[1] #scatestimated\n",
    "    l = figure.marks[2] #lines\n",
    "    s = figure.marks[3] #scat\n",
    "    \n",
    "    simScat.x, simScat.y = s.x, s.y\n",
    "    simScatEstimated.x, simScatEstimated.y = se.x, se.y\n",
    "    simLin.x, simLin.y = l.x, l.y\n",
    "    simDist.x, simDist.y = d.x, d.y\n",
    "    \n",
    "    sc_x = s.scales.get('x')\n",
    "    sc_y = s.scales.get('y')\n",
    "    \n",
    "    simScat.scales = {'x': sc_x, 'y': sc_y}\n",
    "    simScatEstimated.scales = {'x': sc_x, 'y': sc_y}\n",
    "    simLin.scales = {'x': sc_x, 'y': sc_y}\n",
    "    simDist.scales = {'x': sc_x, 'y': sc_y}\n",
    "    \n",
    "    simScat.colors = s.colors\n",
    "    simScatEstimated.colors = se.colors\n",
    "    simLin.colors = l.colors\n",
    "    simDist.colors = d.colors\n",
    "    \n",
    "    simScat.visible = s.visible\n",
    "    simScatEstimated.visible = se.visible\n",
    "    simLin.visible = l.visible\n",
    "    simDist.visible = d.visible\n",
    "    \n",
    "    simScat.selected = None\n",
    "\n",
    "    simPlot.axes[0].label = figure.axes[0].label\n",
    "    simPlot.axes[1].label = figure.axes[1].label\n",
    "    refreshDimensions(simScat.x, simScat.y, simScat, simLin)\n",
    "    simShowRegressionCheckbox.value = False\n",
    "    simShowEstimatedCheckbox.value = False\n",
    "    simShowDistancesCheckbox.value = False\n",
    "    simUpdateRegression(None)\n",
    "    simUpdateDistances(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "simDropdown.observe(changeSim, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "deleteSimButton = widgets.ToggleButton(\n",
    "    description = 'Delete sim',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deleteSim(change):\n",
    "    if deleteSimButton.value:\n",
    "        deleteSimButton.value = False\n",
    "        \n",
    "        name = simDropdown.value\n",
    "        index = 0\n",
    "        \n",
    "        for i in range(len(simDropdown.options)):\n",
    "            opt = simDropdown.options[i]\n",
    "            if opt == name:\n",
    "                index = i\n",
    "                break\n",
    "        \n",
    "        index = index - 1\n",
    "        \n",
    "        simDropdown.value = simDropdown.options[index]\n",
    "        pb.removeSimulation(name)\n",
    "        \n",
    "        refreshSimDropdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "deleteSimButton.observe(deleteSim, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaleX = bqm.LinearScale(min = 0, max = 0)\n",
    "scaleY = bqm.LinearScale(min = 0, max = 0)\n",
    "\n",
    "axisX = bqa.Axis(scale=scaleX,\n",
    "                tick_format='0.2f',\n",
    "                tick_style={'font-size': '15px'},\n",
    "                num_ticks = 5,\n",
    "                grid_lines = 'none',\n",
    "                grid_color = '#8e8e8e', \n",
    "                label='x',\n",
    "                label_location='middle',\n",
    "                label_style={'stroke': 'black', 'default-size': 35},\n",
    "                label_offset='50px')\n",
    "\n",
    "axisY = bqa.Axis(scale=scaleY,\n",
    "                tick_format='0.2f',\n",
    "                tick_style={'font-size': '15px'},\n",
    "                num_ticks = 4,\n",
    "                grid_lines = 'none',\n",
    "                grid_color = '#8e8e8e', \n",
    "                orientation='vertical',\n",
    "                label='y',\n",
    "                label_location='middle',\n",
    "                label_style={'stroke': 'red', 'default_size': 35},\n",
    "                label_offset='50px')\n",
    "\n",
    "tooltipScat = bq.Tooltip(fields=['x', 'y'], labels=[ 'x', 'y'], formats=['4.2f', '4.2f'])\n",
    "\n",
    "simScat = bqm.Scatter(x = np.array([]), \n",
    "                   y = np.array([]), \n",
    "                   scales = {'x': scaleX, 'y': scaleY}, \n",
    "                   enable_move = False,\n",
    "                   tooltip = tooltipScat,\n",
    "                   restrict_x = False,\n",
    "                   restrict_y = False,\n",
    "                   selected_style={'opacity': '1'},\n",
    "                   unselected_style={'opacity': '0.2'},\n",
    "                   )\n",
    "\n",
    "simLin = bqm.Lines(x = np.array([]), \n",
    "                y = np.array([]), \n",
    "                scales = {'x': scaleX, 'y': scaleY}, \n",
    "                visible = False,\n",
    "                colors = ['#fad87c']\n",
    "                )\n",
    "\n",
    "simScatEstimated = bqm.Scatter(x = np.array([]),\n",
    "                             y = np.array([]),\n",
    "                             scales = {'x': scaleX, 'y': scaleY},\n",
    "                             enable_move = False,\n",
    "                             visible = False,\n",
    "                            colors = ['#f87878']\n",
    "                            )\n",
    "\n",
    "simDist = bqm.Lines(x = np.array([]),\n",
    "                 y = np.array([]),\n",
    "                 scales = {'x': scaleX, 'y': scaleY},\n",
    "                 line_style = 'dashed',\n",
    "                 visible = False,\n",
    "                 colors = ['#cdb4c8'],\n",
    "                 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "simPlot = bq.Figure(title='',\n",
    "                marks=[],\n",
    "                axes=[],\n",
    "                animation_duration=500,\n",
    "                layout = widgets.Layout(width='80%', align_self='center'),\n",
    "                legend_location='top-right',\n",
    "                background_style= {'fill': 'white',  'stroke': 'black'},\n",
    "                fig_margin=dict(top=80, bottom=80, left=75, right=20)\n",
    "               )\n",
    "\n",
    "simPlot.marks = [simDist, simScatEstimated, simLin, simScat]\n",
    "simPlot.axes = ([axisX, axisY])\n",
    "\n",
    "simPlotBox = widgets.VBox([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_pz = bq.interacts.PanZoom(allow_pan = True,\n",
    "                          allow_zoom = True,\n",
    "                          scales={'x': [simPlot.scale_x], 'y': [simPlot.scale_y]})\n",
    "\n",
    "sim_pzx = bq.interacts.PanZoom(allow_pan = True,\n",
    "                          allow_zoom = True,\n",
    "                           scales={'x': [simPlot.scale_x]})\n",
    "\n",
    "sim_pzy = bq.interacts.PanZoom(allow_pan = True,\n",
    "                          allow_zoom = True,\n",
    "                           scales={'y': [simPlot.scale_y], })\n",
    "\n",
    "sim_squareSel = bq.interacts.BrushSelector(marks=[simScat], x_scale=simScat.scales['x'], y_scale=simScat.scales['y'])\n",
    "sim_handSel = bq.interacts.LassoSelector(marks=[simScat])\n",
    "\n",
    "#icons from https://fontawesome.com/v4.7.0/icons/\n",
    "sim_zoom_interacts = widgets.ToggleButtons(\n",
    "                                        value = None,\n",
    "                                        options=[\n",
    "                                            ('xy ', sim_pz), \n",
    "                                            ('x ', sim_pzx), \n",
    "                                            ('y ', sim_pzy),  \n",
    "                                            (' ', sim_squareSel),\n",
    "                                            (' ', sim_handSel),\n",
    "                                            (' ', None),],\n",
    "                                            icons = [\"arrows\", \"arrows-h\", \"arrows-v\", \"pencil-square-o\", \"pencil\", \"stop\"],\n",
    "                                            tooltips = [\"zoom/pan in x & y\",\n",
    "                                                        \"zoom/pan in x only\",\n",
    "                                                        \"zoom/pan in y only\",\n",
    "                                                        \"square selector\",\n",
    "                                                        \"lasso selector\",\n",
    "                                                        \"cancel interaction\"],\n",
    "                                        layout = widgets.Layout(\n",
    "                                            width = '50px',\n",
    "                                            margin_left = '0px',\n",
    "                                            margin_right = '0px'\n",
    "                                        ),\n",
    "                                        style = {'button_width' : '50px'}\n",
    "                                        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "link((sim_zoom_interacts, 'value'), (simPlot, 'interaction'));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "simResetZoomButton = widgets.Button(\n",
    "    description='',\n",
    "    disabled=False,\n",
    "    button_style='',\n",
    "    tooltip='Reset zoom',\n",
    "    icon='arrows-alt',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simResetZoom(new):\n",
    "    simScat = simPlot.marks[3]\n",
    "    simLin = simPlot.marks[2]\n",
    "    refreshDimensions(simScat.x, simScat.y, simScat, simLin)\n",
    "    simUpdateDistances(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "simResetZoomButton.on_click(simResetZoom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [],
   "source": [
    "simCompressZoomButton = widgets.Button(\n",
    "    description='',\n",
    "    disabled=False,\n",
    "    button_style='',\n",
    "    tooltip='Zoom to selected area',\n",
    "    icon='compress',\n",
    "    layout = widgets.Layout(width='50px')\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simCompressZoom(new):\n",
    "    if simScat.selected != None:\n",
    "        if len(simScat.selected) > 2:\n",
    "            dataX = np.take(simScat.x, simScat.selected)\n",
    "            dataY = np.take(simScat.y, simScat.selected)   \n",
    "            refreshDimensions(dataX, dataY, simScat, simLin)\n",
    "            simUpdateDistances(None)\n",
    "            sim_zoom_interacts.value = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "simCompressZoomButton.on_click(simCompressZoom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "pointsToolbar = widgets.HBox([], layout = widgets.Layout(align_self = 'center'))\n",
    "\n",
    "addPointsButton = widgets.ToggleButton(\n",
    "    description = 'Add points (OFF)',\n",
    "    button_style = 'warning',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "removePointsButton = widgets.ToggleButton(\n",
    "    description = 'Remove points (OFF)',\n",
    "    button_style = 'danger',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "simSavePNGButton = widgets.ToggleButton(\n",
    "    description = 'Save plot as png',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "pointsToolbar.children = (addPointsButton, removePointsButton, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [],
   "source": [
    "def addPoint(change):\n",
    "\n",
    "    if addPointsButton.value:\n",
    "        removePointsButton.value = False\n",
    "        addPointsButton.description = 'Add points (ON)'\n",
    "        simPlot.interaction = None\n",
    "        simScat.interactions = {'click' : 'add'}\n",
    "\n",
    "    else:\n",
    "        addPointsButton.description = 'Add points (OFF)'\n",
    "        simScat.interactions = {'click' : None}\n",
    "        simScat.observe(null)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "addPointsButton.observe(addPoint, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "def checkAddedPoint(change):\n",
    "    if addPointsButton.value and not removePointsButton.value:\n",
    "        simUpdateRegression(change)\n",
    "        simUpdateDistances(change)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "simScat.observe(checkAddedPoint, 'x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "def removePoint(change):\n",
    "\n",
    "    if removePointsButton.value:\n",
    "        addPointsButton.value = False\n",
    "        removePointsButton.description = 'Remove points (ON)'\n",
    "        simPlot.interaction = None\n",
    "        simScat.on_element_click(deletePoint)\n",
    "    else:\n",
    "        removePointsButton.description = 'Remove points (OFF)'\n",
    "        simScat.on_element_click(deletePoint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deletePoint(scat, point):\n",
    "\n",
    "    if removePointsButton.value and len(simScat.x) > 2:\n",
    "        simPlot.animation_duration=0\n",
    "        i = point.get('data').get('index')\n",
    "        dataX = np.delete(simScat.x, i)\n",
    "        dataY = np.delete(simScat.y, i)\n",
    "        [simScat.x, simScat.y] = dataX, dataY\n",
    "        simUpdateRegression(None)\n",
    "        simUpdateDistances(None)\n",
    "        simPlot.animation_duration=500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "removePointsButton.observe(removePoint, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simSavePNG(change):\n",
    "    if simSavePNGButton.value:\n",
    "        simSavePNGButton.value = False\n",
    "        simPlot.save_png('simulation.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "simSavePNGButton.observe(simSavePNG, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "editPointsBox = widgets.HBox([])\n",
    "\n",
    "editPointsAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%')\n",
    ")\n",
    "\n",
    "\n",
    "editPointsAccordion.set_title(0, 'Edit points')\n",
    "editPointsAccordion.children = (editPointsBox, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [],
   "source": [
    "dragXButton = widgets.ToggleButton(\n",
    "    description = 'X axis (OFF)',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "dragYButton = widgets.ToggleButton(\n",
    "    description = 'Y axis (OFF)',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")\n",
    "\n",
    "editPointsBox.children = (widgets.Label('Make points draggable:'), dragXButton,dragYButton,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drag(change):\n",
    "    \n",
    "    if dragXButton.value:\n",
    "        dragXButton.description = 'X axis (ON)'\n",
    "        simScat.restrict_x = True\n",
    "\n",
    "    elif dragXButton.value == False:\n",
    "        dragXButton.description = 'X axis (OFF)'\n",
    "        simScat.restrict_x = False\n",
    "\n",
    "    if dragYButton.value:\n",
    "        dragYButton.description = 'Y axis (ON)'\n",
    "        simScat.restrict_y = True\n",
    "\n",
    "    elif dragYButton.value == False:\n",
    "        dragYButton.description = 'Y axis (OFF)'\n",
    "        simScat.restrict_y = False\n",
    "        \n",
    "    if dragXButton.value or dragYButton.value:\n",
    "        simScat.enable_move = True     \n",
    "        if dragXButton.value and dragYButton.value:\n",
    "            simScat.restrict_x = False\n",
    "            simScat.restrict_y = False\n",
    "    else:\n",
    "        simScat.enable_move = False     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "dragXButton.observe(drag, 'value')\n",
    "dragYButton.observe(drag, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionOptionsAccordion = widgets.Accordion(\n",
    "    children=[],\n",
    "    layout = widgets.Layout(width='100%')\n",
    ")\n",
    "\n",
    "simRegressionOptionsAccordion.set_title(0, 'Regression')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionOptionsBox = widgets.VBox([])\n",
    "\n",
    "simRegressionBox = widgets.VBox([])\n",
    "\n",
    "simShowRegressionCheckbox = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Show regression',\n",
    "    layout = widgets.Layout(width = '200px')\n",
    ")\n",
    "\n",
    "simRegressionColor = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#fad87c',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "simRegressionOpacity = widgets.FloatSlider(\n",
    "    value=1.0,\n",
    "    min=0,\n",
    "    max=1.0,\n",
    "    step=0.05,\n",
    "    description='Opacity:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width = '350px')\n",
    ")\n",
    "\n",
    "simRegressionBox.children = (widgets.HTML(value='<h4>Edit regression:</h4>'), widgets.HBox([simRegressionColor, simRegressionOpacity]))\n",
    "\n",
    "simRegressionOptionsBox.children = (simShowRegressionCheckbox,)\n",
    "simRegressionOptionsAccordion.children = (simRegressionOptionsBox,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "def callUpdateRegression(a, b):\n",
    "    simUpdateRegression(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simShowRegression(change):\n",
    "    if simShowRegressionCheckbox.value:\n",
    "        simLin.visible = True\n",
    "        simScat.on_drag_end(callUpdateRegression)\n",
    "        simUpdateRegression(change)\n",
    "        simUpdateDistances(change)\n",
    "\n",
    "    else:\n",
    "        simLin.visible = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "simShowRegressionCheckbox.observe(simShowRegression, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simChangeRegressionColor(change):\n",
    "    simLin.colors = [simRegressionColor.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionColor.observe(simChangeRegressionColor, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simChangeRegressionOpacity(change):\n",
    "    simLin.opacities = [simRegressionOpacity.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionOpacity.observe(simChangeRegressionOpacity, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionDecimals = widgets.Dropdown(\n",
    "    options = [i for i in range(0,14)],\n",
    "    value = 2,\n",
    "    description='<h4>Number of decimals: </h4>',\n",
    "    style = style_1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionOrder = widgets.IntSlider(\n",
    "    value=1.0,\n",
    "    min=1.0,\n",
    "    max=5.0,\n",
    "    description='',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    layout = widgets.Layout(width = '200px'),\n",
    ")\n",
    "\n",
    "simRegressionErrorText = widgets.HTML(\n",
    "    value = \"\",\n",
    ")\n",
    "\n",
    "simRegressionValues = widgets.VBox()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simUpdateRegression(change=None):\n",
    "\n",
    "    if simRegressionExpression not in simRegressionOptionsBox.children:\n",
    "    \n",
    "        simRegressionOptionsBox.children = [widgets.HBox([simShowRegressionCheckbox, widgets.Label('Order of regression'), simRegressionOrder]),\n",
    "                                            simRegressionExpression,\n",
    "                                            simRegressionValues,\n",
    "                                            simRegressionDecimals,\n",
    "                                            widgets.HTML(value='<br>'),\n",
    "                                            widgets.HBox([simShowDistancesCheckbox,simShowEstimatedCheckbox]),\n",
    "                                            widgets.HTML(value='<hr>'),\n",
    "                                            simRegressionBox,\n",
    "                                            simDistancesBox,\n",
    "                                            simEstimatedBox\n",
    "                                           ]                                         \n",
    "\n",
    "    if simScat.selected == None:\n",
    "        \n",
    "        dataX = simScat.x\n",
    "        dataY = simScat.y\n",
    "        \n",
    "    else:\n",
    "\n",
    "        if len(simScat.selected) < 3:\n",
    "\n",
    "            dataX = simScat.x\n",
    "            dataY = simScat.y\n",
    "\n",
    "        else:\n",
    "\n",
    "            dataX = np.take(simScat.x, simScat.selected)\n",
    "            dataY = np.take(simScat.y, simScat.selected)    \n",
    "       \n",
    "    \n",
    "    simLin.x = np.linspace(start=np.min(dataX), stop=np.max(dataX), num=1000)\n",
    "    \n",
    "    try:\n",
    "        if len(dataX) > simRegressionOrder.value + 1:\n",
    "            poly, cov = np.polyfit(dataX, dataY, simRegressionOrder.value, cov=True)\n",
    "            simRegressionErrorText.value  = ''\n",
    "        \n",
    "        else:\n",
    "            poly = np.polyfit(dataX, dataY, len(dataX) - 1)\n",
    "            cov = np.zeros([len(poly),len(poly)])\n",
    "\n",
    "            if simRegressionOrder.value >= len(simScat.x):\n",
    "                simRegressionErrorText.value = \"<span style='color:red'><b>You need more points for a regression of order \" + str(simRegressionOrder.value) + \"</b></span>\"\n",
    "            else:\n",
    "                simRegressionErrorText.value = ''\n",
    "    except:\n",
    "        return None\n",
    "    \n",
    "    simLin.y = np.polyval(poly, simLin.x)\n",
    "    \n",
    "    if sim_squareSel.brushing == False:\n",
    "    \n",
    "        expression = '\\(y = \\;\\)'\n",
    "        maxPower = len(poly)-1\n",
    "\n",
    "        decimals = simRegressionDecimals.value\n",
    "        chars = 'abcdef'\n",
    "\n",
    "        errors = np.sqrt(np.diag(cov))\n",
    "\n",
    "        simRegressionValues.children = []\n",
    "\n",
    "        for i in range(len(poly)):\n",
    "\n",
    "            coef = np.around([ poly[i],],decimals)[0]\n",
    "\n",
    "            error = np.around([errors[i],], decimals)[0]\n",
    "\n",
    "            power = maxPower-i\n",
    "\n",
    "            if power == 1:\n",
    "\n",
    "                expression = expression + '\\(' + chars[i] + '\\; x \\; + \\; \\)' \n",
    "\n",
    "            elif power == 0:\n",
    "                expression = expression + '\\(' + chars[i] + ' \\)'\n",
    "\n",
    "            else:\n",
    "                expression = expression + '\\(' + chars[i] + '\\; x^{' + str(power) + '} \\; + \\; \\)'\n",
    "\n",
    "            s = '\\(' + chars[i] + '\\; = \\; ' + str(coef) + '\\; \\pm \\;' + str(error) + '\\)'\n",
    "            simRegressionValues.children = simRegressionValues.children + (widgets.HTMLMath(value = s , description = ''), )\n",
    "\n",
    "        simRegressionExpression.value = expression\n",
    "\n",
    "        errors = np.sqrt(np.diag(cov))\n",
    "        errorsExp = ''\n",
    "\n",
    "        for error in errors:\n",
    "            error = np.around([error,], decimals)[0]\n",
    "            errorsExp = errorsExp + '\\(' + str(error) + '\\; \\; \\; \\)'\n",
    "\n",
    "        simErrorsExpression.value = errorsExp    \n",
    "\n",
    "        simUpdateDistances(change)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionOrder.observe(simUpdateRegression, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionDecimals.observe(simUpdateRegression, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "simScat.observe(simUpdateRegression, 'selected')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [],
   "source": [
    "sim_squareSel.observe(simUpdateRegression, 'brushing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [],
   "source": [
    "simRegressionExpression = widgets.HTMLMath(\n",
    "    value = '\\(y =\\)',\n",
    "    description = 'Expression:'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "simErrorsExpression  = widgets.HTMLMath(\n",
    "    value = '',\n",
    "    description = 'Errors:'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simUpdateDistances(change):\n",
    "\n",
    "    scaleX = simScat.scales.get('x')\n",
    "    scaleY = simScat.scales.get('y')\n",
    "    \n",
    "    simDist.scales = {'x': scaleX, 'y': scaleY}\n",
    "    simScatEstimated.scales = {'x': scaleX, 'y': scaleY}\n",
    "    \n",
    "    x = simScat.x\n",
    "    y = simScat.y\n",
    "    \n",
    "    try:\n",
    "        yInterp = np.interp(x, simLin.x, simLin.y) \n",
    "    \n",
    "    except:\n",
    "        return None\n",
    "    \n",
    "    simScatEstimated.x = x\n",
    "    simScatEstimated.y = yInterp    \n",
    "    \n",
    "    xVal = []\n",
    "    yVal = []\n",
    "\n",
    "    for i in range(len(x)):\n",
    "        for j in range(2):\n",
    "            xVal.append(x[i])\n",
    "        yVal.append(min(y[i],yInterp[i]))\n",
    "        yVal.append(max(y[i],yInterp[i]))\n",
    "        \n",
    "    xDef = []\n",
    "    yDef = []\n",
    "\n",
    "    for i in range(0, len(xVal), 2):\n",
    "        xDef.append(np.array([xVal[i], xVal[i+1]]))\n",
    "        yDef.append(np.array([yVal[i], yVal[i+1]]))\n",
    "        \n",
    "    simDist.x = xDef\n",
    "    simDist.y = yDef"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [],
   "source": [
    "simDistancesBox = widgets.VBox([])\n",
    "\n",
    "simShowDistancesCheckbox = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Show distances',\n",
    ")\n",
    "\n",
    "simDistancesColor = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#cdb4c8',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "simDistancesOpacity = widgets.FloatSlider(\n",
    "    value=1.0,\n",
    "    min=0,\n",
    "    max=1.0,\n",
    "    step=0.05,\n",
    "    description='Opacity:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width='350px')\n",
    ")\n",
    "\n",
    "simDistancesBox.children = (widgets.HTML(value='<h4>Edit distances:</h4>'), widgets.HBox([simDistancesColor, simDistancesOpacity]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simShowDistances(change):\n",
    "    \n",
    "    if simShowDistancesCheckbox.value:\n",
    "        simDist.visible = True\n",
    "        simUpdateRegression(change)\n",
    "        \n",
    "    else:\n",
    "        simDist.visible = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [],
   "source": [
    "simShowDistancesCheckbox.observe(simShowDistances, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simChangeDistancesColor(change):\n",
    "    simDist.colors = [simDistancesColor.value for elem in simDist.x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [],
   "source": [
    "simDistancesColor.observe(simChangeDistancesColor, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simChangeDistancesOpacity(change):\n",
    "    simDist.opacities = [simDistancesOpacity.value for elem in simDist.x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [],
   "source": [
    "simDistancesOpacity.observe(simChangeDistancesOpacity, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [],
   "source": [
    "simEstimatedBox = widgets.VBox([])\n",
    "\n",
    "simShowEstimatedCheckbox = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Show estimated points',\n",
    ")\n",
    "\n",
    "simEstimatedColor = widgets.ColorPicker(\n",
    "    concise=False,\n",
    "    description='',\n",
    "    value='#f87878',\n",
    "    disabled=False\n",
    ")\n",
    "\n",
    "simEstimatedOpacity = widgets.FloatSlider(\n",
    "    value=1.0,\n",
    "    min=0,\n",
    "    max=1.0,\n",
    "    step=0.05,\n",
    "    description='Opacity:',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    "    layout = widgets.Layout(width='350px')\n",
    ")\n",
    "\n",
    "simEstimatedBox.children = (widgets.HTML(value='<h4>Edit estimated points:</h4>'), widgets.HBox([simEstimatedColor, simEstimatedOpacity]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simShowEstimated(change):\n",
    "    \n",
    "    if simShowEstimatedCheckbox.value:\n",
    "        simScatEstimated.visible = True\n",
    "        simUpdateRegression(change)\n",
    "        \n",
    "    else:\n",
    "        simScatEstimated.visible = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "simShowEstimatedCheckbox.observe(simShowEstimated, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simChangeEstimatedColor(change):\n",
    "    simScatEstimated.colors = [simEstimatedColor.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "simEstimatedColor.observe(simChangeEstimatedColor, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simChangeEstimatedOpacity(change):\n",
    "    simScatEstimated.default_opacities = [simEstimatedOpacity.value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "simEstimatedOpacity.observe(simChangeEstimatedOpacity, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [],
   "source": [
    "simText = widgets.HTML(\n",
    "    value = \"<br><h2>Your simulation:</h2>\"    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "saveSimButton = widgets.ToggleButton(\n",
    "    description = 'Save simulation',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "simName = widgets.Text(\n",
    "    value='',\n",
    "    placeholder=\"Simulation's name:\",\n",
    "    description=\"<h4>Name: </h4>\",\n",
    "    disabled=False,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [],
   "source": [
    "def saveSim(change):\n",
    "    if saveSimButton.value:\n",
    "        saveSimButton.value = False\n",
    "        pb.addPlot(simPlot, simName.value)\n",
    "        simName.value = ''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [],
   "source": [
    "saveSimButton.observe(saveSim, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [],
   "source": [
    "discardButton = widgets.ToggleButton(\n",
    "    description = 'Discard changes',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discardChanges(change):\n",
    "    if discardButton.value:\n",
    "        discardButton.value = False\n",
    "        changeSim(change)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [],
   "source": [
    "discardButton.observe(discardChanges, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [],
   "source": [
    "simPlotBox.children = (widgets.HBox([simPlot, widgets.VBox([widgets.HTML(value='<br/>'), sim_zoom_interacts, simCompressZoomButton, simResetZoomButton], layout = widgets.Layout(width='10%'))]), )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [],
   "source": [
    "simBlock.children = [simText, widgets.HBox([simDropdown,deleteSimButton], layout = widgets.Layout(align_self = 'center')), simPlotBox, pointsToolbar, widgets.HBox([simName, saveSimButton,discardButton]), changeViewButton, editPointsAccordion, simRegressionOptionsAccordion, ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {},
   "outputs": [],
   "source": [
    "savedBlock = widgets.VBox([], layout=widgets.Layout(width='50%', border='solid 1px', padding='20px'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {},
   "outputs": [],
   "source": [
    "savedText = widgets.HTML(\n",
    "    value = \"<br><h2>Your plots:</h2>\"    \n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotDropdown = widgets.Dropdown(\n",
    "    options = [],\n",
    "    #value = 2,\n",
    "    description='<h4>Choose your plot: </h4>',\n",
    "    style = style_1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "def refreshPlotDropdown():\n",
    "    plotDropdown.options = pb.getPlots()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [],
   "source": [
    "def changePlot(change):\n",
    "    name = plotDropdown.value\n",
    "    plot = pb.getPlot(name)\n",
    "    savedBlock.children = [savedText, widgets.HBox([plotDropdown, deletePlotButton], layout = widgets.Layout(align_self = 'center')), plot]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotDropdown.observe(changePlot, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [],
   "source": [
    "deletePlotButton = widgets.ToggleButton(\n",
    "    description = 'Delete plot',\n",
    "    button_style = '',\n",
    "    style = style_1,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [],
   "source": [
    "def deletePlot(change):\n",
    "    if deletePlotButton.value:\n",
    "        deletePlotButton.value = False\n",
    "        \n",
    "        name = plotDropdown.value\n",
    "        index = 0\n",
    "        \n",
    "        for i in range(len(plotDropdown.options)):\n",
    "            opt = plotDropdown.options[i]\n",
    "            if opt == name:\n",
    "                index = i\n",
    "                break\n",
    "        \n",
    "        index = index - 1\n",
    "        \n",
    "        plotDropdown.value = plotDropdown.options[index]\n",
    "        pb.removePlot(name)\n",
    "        \n",
    "        refreshPlotDropdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "deletePlotButton.observe(deletePlot, 'value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [],
   "source": [
    "savedBlock.children = [savedText, plotDropdown]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ed889d080d1a4672885452d262e50359",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(VBox(children=(HTML(value='<h1>Start working: open your data</h1> <hr>'), VBox(children=(HTML(v…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mainBlock"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}